code.py

"""Planning — decide the whole sequence of steps before executing any of them.

Different from prompt chaining: there the steps are hardcoded by you, here the
model designs the step list at runtime based on the goal. That is the tradeoff
- flexibility for unpredictability.

The plan is data (a JSON list), which is what makes it inspectable, editable,
and replayable before you spend tokens executing it.
"""

from langchain_core.prompts import ChatPromptTemplate

from resources.agent import llm
from resources.helper import parse_json, show_response

GOAL = (
    "Migrate a small Flask app from SQLite to PostgreSQL without downtime "
    "for its ~500 daily users."
)

plan_prompt = ChatPromptTemplate.from_template(
    "Break this goal into 4-6 ordered, concrete steps.\n"
    'Reply with a JSON array of objects: [{{"step": 1, "action": "...", '
    '"why": "..."}}]\n'
    "JSON only, no markdown fences.\n\nGoal: {goal}"
)

execute_prompt = ChatPromptTemplate.from_template(
    "You are executing one step of a larger plan.\n\n"
    "Overall goal: {goal}\n"
    "Steps already done: {done}\n\n"
    "Now do step {number}: {action}\n"
    "Give the concrete output for this step in under 120 words."
)


def make_plan(goal):
    """Ask for a plan and parse it into real data we can inspect."""
    reply = llm.invoke(plan_prompt.format(goal=goal))
    show_response(reply)

    # Models wrap JSON in fences and add preambles even when told not to, so
    # parse defensively rather than trusting the instruction - this is the
    # boundary where a plan stops being prose and becomes data.
    return parse_json(reply.content)


if __name__ == "__main__":
    print(f"GOAL: {GOAL}")
    plan = make_plan(GOAL)

    # The plan exists as data before anything runs, so it can be reviewed,
    # reordered, or rejected without burning a single execution call.
    print(f"\n{'=' * 60}\nPLAN ({len(plan)} steps)\n{'=' * 60}")
    for item in plan:
        print(f"  {item['step']}. {item['action']}")
        print(f"     why: {item['why']}")

    # Execute in order, passing completed steps forward so each step knows
    # what has already happened.
    done = []
    for item in plan:
        print(f"\n{'=' * 60}\nEXECUTING STEP {item['step']}\n{'=' * 60}")
        result = llm.invoke(
            execute_prompt.format(
                goal=GOAL,
                done="; ".join(done) or "none",
                number=item["step"],
                action=item["action"],
            )
        )
        show_response(result)
        done.append(item["action"])