v0.2.1 production RC — AST security validator, OutputTier, reference validation

agent_generator_pkg/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "hatchling.build"
 
 [project]
 name            = "agent-generator"
-version         = "0.2.0"
+version         = "0.2.1"
 description     = "Turn plain-English requirements into production-ready multi-agent AI projects (CrewAI, LangGraph, WatsonX Orchestrate)."
 readme          = "README.md"
 requires-python = ">=3.10"
@@ -78,6 +78,10 @@ web = [
 all = [
   "agent-generator[openai,crewai,langgraph,web]",
 ]
+release = [
+  "build>=1.2",
+  "twine>=5.0",
+]
 dev = [
   "pytest>=8.2",
   "pytest-xdist>=3.5",

agent_generator_pkg/src/agent_generator/__init__.py

@@ -21,7 +21,7 @@ from __future__ import annotations
 # ------------------------------------------------------------------ #
 # Version
 # ------------------------------------------------------------------ #
-__version__: str = "0.2.0"
+__version__: str = "0.2.1"
 
 # ------------------------------------------------------------------ #
 # Surface imports (lazy‑safe)

agent_generator_pkg/src/agent_generator/application/build_service.py

@@ -70,7 +70,8 @@ def build(
         path="README.md",
         content=(
             f"# {project_name}\n\n{spec.description}\n\n"
-            f"Framework: {framework_name}\n\n"
+            f"Framework: {framework_name}\n"
+            f"Tier: {spec.template_tier.value}\n\n"
             f"Generated by [agent-generator](https://github.com/ruslanmv/agent-generator).\n"
         ),
         language="markdown",
@@ -93,8 +94,9 @@ def build(
     manifest: dict[str, Any] = {
         "framework": framework_name,
         "diagram": diagram,
-        "generator_version": "0.2.0",
+        "generator_version": "0.2.1",
         "project_name": project_name,
+        "template_tier": spec.template_tier.value,
     }
 
     artifact = ArtifactBundle(

agent_generator_pkg/src/agent_generator/application/planning_service.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import re
+import warnings as _warnings
 from typing import Optional
 
 from agent_generator.domain.project_spec import (
@@ -9,6 +10,7 @@ from agent_generator.domain.project_spec import (
     ArtifactMode,
     FrameworkChoice,
     LLMSpec,
+    OutputTier,
     ProjectSpec,
     RuntimeSpec,
     TaskSpec,
@@ -16,11 +18,10 @@ from agent_generator.domain.project_spec import (
 )
 from agent_generator.planners.keyword_planner import KeywordPlanner
 from agent_generator.planners.spec_normalizer import SpecNormalizer
-from agent_generator.validators.spec_validator import SpecValidator
+from agent_generator.application.validation_service import validate_spec
 
 _keyword_planner = KeywordPlanner()
 _normalizer = SpecNormalizer()
-_validator = SpecValidator()
 
 
 def _slugify(text: str) -> str:
@@ -100,6 +101,10 @@ def plan(
 
     # ── Optional LLM planning stage ──────────────────────────────
     if use_llm and provider:
+        _warnings.warn(
+            "LLM-based planning is experimental and not enabled by default.",
+            stacklevel=2,
+        )
         try:
             from agent_generator.providers import PROVIDERS
 
@@ -111,9 +116,9 @@ def plan(
                 llm_planner = LLMPlanner(provider_inst)
                 llm_spec = llm_planner.plan(prompt, hints)
                 if llm_spec is not None:
-                    spec, warnings = _normalizer.normalize(llm_spec)
-                    validation = _validator.validate(spec)
-                    return spec, warnings + validation.warnings
+                    spec, norm_warnings = _normalizer.normalize(llm_spec)
+                    validation = validate_spec(spec)
+                    return spec, norm_warnings + validation.warnings
         except Exception:
             pass  # Fall through to keyword-based planning
 
@@ -132,6 +137,7 @@ def plan(
         description=prompt[:500],
         framework=FrameworkChoice(fw),
         artifact_mode=ArtifactMode(mode),
+        template_tier=OutputTier.PRODUCTION,
         llm=LLMSpec(provider=provider or "watsonx"),
         agents=[AgentSpec(**a) for a in agents],
         tasks=[TaskSpec(**t) for t in tasks],
@@ -143,7 +149,7 @@ def plan(
     spec, norm_warnings = _normalizer.normalize(spec)
 
     # Step 4: validate
-    validation = _validator.validate(spec)
+    validation = validate_spec(spec)
     all_warnings = norm_warnings + validation.warnings
 
     if not validation.valid:

agent_generator_pkg/src/agent_generator/cli.py

@@ -54,7 +54,7 @@ app = typer.Typer(
 
 console = Console()
 
-VERSION = "0.2.0"  # 🛈 bump on release
+VERSION = "0.2.1"  # 🛈 bump on release
 
 
 # ---------------------------------------------------------------- #

agent_generator_pkg/src/agent_generator/domain/project_spec.py

@@ -1,10 +1,10 @@
-"""Canonical project specification -- the single source of truth between planning and rendering."""
+"""Canonical project specification — the single source of truth."""
 from __future__ import annotations
 
 from enum import Enum
 from typing import Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 
 class FrameworkChoice(str, Enum):
@@ -21,54 +21,45 @@ class ArtifactMode(str, Enum):
     CODE_AND_YAML = "code_and_yaml"
 
 
-class AgentSpec(BaseModel):
-    """Specification for a single agent in the project."""
+class OutputTier(str, Enum):
+    STARTER = "starter"
+    PRODUCTION = "production"
+
 
+class AgentSpec(BaseModel):
     id: str = Field(..., description="Unique agent identifier (snake_case).")
     role: str = Field(..., description="Agent role name.")
     goal: str = Field(..., description="What this agent tries to achieve.")
     backstory: str = Field(default="", description="Background context for the agent.")
     tools: list[str] = Field(default_factory=list, description="Tool IDs this agent can use.")
-    llm_override: Optional[str] = Field(
-        default=None, description="Override LLM model for this agent."
-    )
+    llm_override: Optional[str] = Field(default=None, description="Optional model override.")
 
 
 class TaskSpec(BaseModel):
-    """Specification for a single task in the project."""
-
     id: str = Field(..., description="Unique task identifier (snake_case).")
     description: str = Field(..., description="What this task does.")
     agent_id: str = Field(..., description="ID of the agent responsible.")
     expected_output: str = Field(..., description="What the task should produce.")
-    depends_on: list[str] = Field(
-        default_factory=list, description="IDs of prerequisite tasks."
-    )
+    depends_on: list[str] = Field(default_factory=list, description="IDs of prerequisite tasks.")
 
 
 class ToolSpec(BaseModel):
-    """Specification for a tool pulled from the tool catalog."""
-
     id: str = Field(..., description="Unique tool identifier.")
-    template: str = Field(..., description="Key in the tool catalog.")
-    inputs: dict[str, str] = Field(
-        default_factory=dict, description="Template variable overrides."
-    )
+    template: str = Field(..., description="Tool catalog template key.")
+    inputs: dict[str, str] = Field(default_factory=dict, description="Template variable overrides.")
 
 
 class LLMSpec(BaseModel):
-    """LLM provider and model configuration."""
-
     provider: str = Field(default="watsonx")
     model: str = Field(default="meta-llama/llama-3-3-70b-instruct")
+    temperature: float = Field(default=0.0, ge=0.0, le=2.0)
 
 
 class RuntimeSpec(BaseModel):
-    """Runtime options for the generated project."""
-
     serve_api: bool = Field(default=False)
     mcp_wrapper: bool = Field(default=False)
     mcp_port: int = Field(default=8080, ge=1, le=65535)
+    healthcheck_path: str = Field(default="/health")
 
 
 class ProjectSpec(BaseModel):
@@ -80,11 +71,9 @@ class ProjectSpec(BaseModel):
         pattern=r"^[a-z0-9][a-z0-9-]*$",
     )
     version: str = Field(default="1.0", description="Schema version.")
-    template_tier: str = Field(default="production", description="Template tier: starter or production.")
-    metadata: dict[str, str] = Field(default_factory=dict, description="Arbitrary metadata tags.")
-    description: str = Field(
-        ..., description="One-line project description.", max_length=500
-    )
+    template_tier: OutputTier = Field(default=OutputTier.PRODUCTION)
+    metadata: dict[str, str] = Field(default_factory=dict)
+    description: str = Field(..., max_length=500)
     framework: FrameworkChoice
     artifact_mode: ArtifactMode = Field(default=ArtifactMode.CODE_ONLY)
     llm: LLMSpec = Field(default_factory=LLMSpec)
@@ -92,3 +81,23 @@ class ProjectSpec(BaseModel):
     tasks: list[TaskSpec] = Field(..., min_length=1)
     tools: list[ToolSpec] = Field(default_factory=list)
     runtime: RuntimeSpec = Field(default_factory=RuntimeSpec)
+
+    @model_validator(mode="after")
+    def validate_references(self) -> "ProjectSpec":
+        agent_ids = {a.id for a in self.agents}
+        task_ids = {t.id for t in self.tasks}
+        tool_ids = {t.id for t in self.tools}
+
+        for task in self.tasks:
+            if task.agent_id not in agent_ids:
+                raise ValueError(f"Task '{task.id}' references unknown agent '{task.agent_id}'")
+            for dep in task.depends_on:
+                if dep not in task_ids:
+                    raise ValueError(f"Task '{task.id}' depends on unknown task '{dep}'")
+
+        for agent in self.agents:
+            for tool_id in agent.tools:
+                if tool_id not in tool_ids:
+                    raise ValueError(f"Agent '{agent.id}' references unknown tool '{tool_id}'")
+
+        return self

agent_generator_pkg/src/agent_generator/validators/security_validator.py

@@ -1,29 +1,66 @@
-"""Security validator — blocks unsafe patterns in generated code."""
+"""AST-based security validator — blocks unsafe patterns in generated code."""
 from __future__ import annotations
 
+import ast
+
 from agent_generator.domain.artifact_bundle import ArtifactBundle, ValidationIssue
 
-FORBIDDEN_PATTERNS: list[tuple[str, str]] = [
-    ("eval(", "eval() is unsafe — use ast.literal_eval or a safe evaluator"),
-    ("exec(", "exec() is unsafe — avoid dynamic code execution"),
-    ("subprocess.Popen(", "subprocess.Popen without restrictions is unsafe"),
-    ("os.system(", "os.system() is unsafe — use subprocess with shell=False"),
-    ("__import__(", "__import__() is unsafe — use regular imports"),
-]
+FORBIDDEN_CALLS = {"eval", "exec", "__import__"}
+
+FORBIDDEN_ATTR_CALLS = {
+    ("os", "system"),
+    ("subprocess", "Popen"),
+    ("subprocess", "call"),
+    ("subprocess", "run"),
+}
+
+
+class _SecurityVisitor(ast.NodeVisitor):
+    def __init__(self, path: str) -> None:
+        self.path = path
+        self.issues: list[ValidationIssue] = []
+
+    def visit_Call(self, node: ast.Call) -> None:
+        if isinstance(node.func, ast.Name) and node.func.id in FORBIDDEN_CALLS:
+            self.issues.append(ValidationIssue(
+                level="error",
+                message=f"{self.path}: forbidden call '{node.func.id}()' detected",
+            ))
+        if isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Name):
+            key = (node.func.value.id, node.func.attr)
+            if key in FORBIDDEN_ATTR_CALLS:
+                self.issues.append(ValidationIssue(
+                    level="error",
+                    message=f"{self.path}: forbidden call '{key[0]}.{key[1]}()' detected",
+                ))
+        self.generic_visit(node)
 
 
 class SecurityValidator:
-    """Scan generated artifacts for forbidden code patterns."""
+    """Scan generated artifacts for forbidden code patterns using AST analysis."""
 
     def validate(self, artifact: ArtifactBundle) -> list[ValidationIssue]:
         issues: list[ValidationIssue] = []
         for file in artifact.files:
             if not file.path.endswith(".py"):
                 continue
-            for pattern, reason in FORBIDDEN_PATTERNS:
-                if pattern in file.content:
-                    issues.append(ValidationIssue(
-                        level="error",
-                        message=f"{file.path}: {reason}",
-                    ))
+            try:
+                tree = ast.parse(file.content)
+            except SyntaxError as exc:
+                issues.append(ValidationIssue(
+                    level="error",
+                    message=f"{file.path}: syntax error during security scan: {exc.msg}",
+                ))
+                continue
+
+            visitor = _SecurityVisitor(file.path)
+            visitor.visit(tree)
+            issues.extend(visitor.issues)
+
+            # Warn on requests calls without timeout
+            if "requests." in file.content and "timeout=" not in file.content:
+                issues.append(ValidationIssue(
+                    level="warning",
+                    message=f"{file.path}: HTTP request may be missing timeout parameter",
+                ))
         return issues

agent_generator_pkg/src/agent_generator/web/routes/api.py

@@ -24,10 +24,10 @@ from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel, Field, ValidationError
 
+from agent_generator.application.planning_service import plan as plan_spec
+from agent_generator.application.build_service import build_dict
 from agent_generator.config import Settings, get_settings
 from agent_generator.frameworks import FRAMEWORKS
-from agent_generator.utils.parser import parse_natural_language_to_workflow
-from agent_generator.utils.visualizer import to_mermaid
 from agent_generator.web.inference import (
     get_inference_client,
     get_inference_settings,
@@ -121,43 +121,18 @@ async def plan(req: PlanRequest):
     if not prompt:
         raise HTTPException(status_code=400, detail="Prompt is required.")
 
-    framework = req.framework if req.framework in FRAMEWORKS else "crewai"
-
-    workflow = parse_natural_language_to_workflow(prompt)
-
-    agents: list[AgentInfo] = []
-    if hasattr(workflow, "agents"):
-        for a in workflow.agents:
-            agents.append(AgentInfo(
-                role=a.role if hasattr(a, "role") else str(a),
-                goal=a.goal if hasattr(a, "goal") else "",
-                tools=a.tools if hasattr(a, "tools") else [],
-            ))
-
-    tasks: list[TaskInfo] = []
-    if hasattr(workflow, "tasks"):
-        for t in workflow.tasks:
-            tasks.append(TaskInfo(
-                description=t.description if hasattr(t, "description") else str(t),
-                agent_role=t.agent_id if hasattr(t, "agent_id") else "",
-                expected_output=t.expected_output if hasattr(t, "expected_output") else "",
-                depends_on=t.depends_on if hasattr(t, "depends_on") else [],
-            ))
-
-    warnings: list[str] = []
-    if not agents:
-        warnings.append("No agents detected. The LLM will infer agent roles.")
-    if not tasks:
-        warnings.append("No tasks detected. The LLM will generate default tasks.")
-
-    name = workflow.name if hasattr(workflow, "name") and workflow.name else "agent-project"
-    description = workflow.description if hasattr(workflow, "description") and workflow.description else prompt[:200]
+    fw = req.framework if req.framework in FRAMEWORKS else None
+    spec, warnings = plan_spec(prompt, framework=fw)
+
+    agents = [AgentInfo(role=a.role, goal=a.goal, tools=a.tools) for a in spec.agents]
+    tasks = [TaskInfo(description=t.description, agent_role=t.agent_id,
+                      expected_output=t.expected_output, depends_on=t.depends_on) for t in spec.tasks]
 
     return ProjectPlan(
-        name=name,
-        description=description,
-        framework=framework,
-        artifact_mode=req.artifact_mode,
+        name=spec.name,
+        description=spec.description,
+        framework=spec.framework.value,
+        artifact_mode=req.artifact_mode or spec.artifact_mode.value,
         agents=agents,
         tasks=tasks,
         warnings=warnings,
@@ -167,52 +142,23 @@ async def plan(req: PlanRequest):
 @router.post("/build", response_model=BuildResponse)
 async def build(req: BuildRequest):
     """Take a structured plan and produce code artifacts."""
-    plan = req.plan
-    framework = plan.framework if plan.framework in FRAMEWORKS else "crewai"
+    p = req.plan
+    fw = p.framework if p.framework in FRAMEWORKS else "crewai"
 
-    try:
-        settings = Settings(
-            provider=req.provider or get_settings().provider,
-            model=req.model or get_settings().model,
-            temperature=req.temperature if req.temperature is not None else get_settings().temperature,
-            max_tokens=get_settings().max_tokens,
-        )
-    except (ValidationError, Exception):
-        settings = get_settings()
-
-    # Reconstruct prompt from plan for the parser
-    prompt_parts = [f"Project: {plan.name}", f"Description: {plan.description}"]
-    for a in plan.agents:
-        prompt_parts.append(f"Agent '{a.role}': {a.goal}")
-    for t in plan.tasks:
-        prompt_parts.append(f"Task: {t.description} (assigned to {t.agent_role})")
-    combined_prompt = "\n".join(prompt_parts)
-
-    workflow = parse_natural_language_to_workflow(combined_prompt)
-    generator_cls = FRAMEWORKS[framework]
-    generator = generator_cls()
-    code = generator.generate_code(workflow, settings, mcp=req.mcp)
-    diagram = to_mermaid(workflow)
-
-    files = [
-        FileArtifact(path=f"src/{plan.name}/main.py", content=code, language="python"),
-        FileArtifact(path=f"src/{plan.name}/__init__.py", content=f'"""Generated {plan.name} package."""\n', language="python"),
-    ]
-
-    errors: list[str] = []
-    warnings = list(plan.warnings)
-
-    if len(code) < 50:
-        warnings.append("Generated code is very short.")
+    spec, _ = plan_spec(p.description, framework=fw)
+    result = build_dict(spec, mcp=req.mcp)
+
+    files = [FileArtifact(path=path, content=content, language="python" if path.endswith(".py") else "yaml")
+             for path, content in result.get("files", {}).items()]
 
     return BuildResponse(
-        project_name=plan.name,
-        framework=framework,
+        project_name=spec.name,
+        framework=fw,
         files=files,
-        diagram=diagram,
-        errors=errors,
-        warnings=warnings,
-        validation_passed=len(errors) == 0,
+        diagram=result.get("diagram", ""),
+        errors=result.get("errors", []),
+        warnings=result.get("warnings", []) + list(p.warnings),
+        validation_passed=result.get("valid", True),
     )
 
 
@@ -220,40 +166,28 @@ async def build(req: BuildRequest):
 async def generate(req: GenerateRequest):
     """Combined plan + build endpoint (backward compatible)."""
     prompt = req.prompt.strip()
-    framework_name = req.framework.strip()
-    provider_name = req.provider or get_settings().provider
-    mcp = req.mcp
-
-    if not prompt or framework_name not in FRAMEWORKS:
-        raise HTTPException(
-            status_code=400,
-            detail="Missing prompt or unknown framework.",
-        )
+    fw = req.framework.strip() if req.framework.strip() in FRAMEWORKS else None
 
-    try:
-        settings = Settings(
-            provider=provider_name,
-            model=req.model or get_settings().model,
-            temperature=req.temperature if req.temperature is not None else get_settings().temperature,
-            max_tokens=req.max_tokens or get_settings().max_tokens,
-        )
-    except ValidationError as exc:
-        raise HTTPException(status_code=400, detail=str(exc.errors()))
+    if not prompt:
+        raise HTTPException(status_code=400, detail="Prompt is required.")
 
-    workflow = parse_natural_language_to_workflow(prompt)
-    generator_cls = FRAMEWORKS[framework_name]
-    generator = generator_cls()
-    code = generator.generate_code(workflow, settings, mcp=mcp)
+    spec, warnings = plan_spec(prompt, framework=fw)
+    result = build_dict(spec, mcp=req.mcp)
 
-    warnings: list[str] = []
-    if len(code) < 50:
-        warnings.append("Generated code is very short.")
+    # Pick the main code file
+    code = ""
+    for path, content in result.get("files", {}).items():
+        if path.endswith((".py", ".yaml")) and ("main" in path or path.endswith(".yaml")):
+            code = content
+            break
+    if not code:
+        code = next(iter(result.get("files", {}).values()), "")
 
     return GenerateResponse(
         code=code,
-        diagram=to_mermaid(workflow),
-        framework=framework_name,
-        warnings=warnings,
+        diagram=result.get("diagram", ""),
+        framework=spec.framework.value,
+        warnings=warnings + result.get("warnings", []),
     )
 
 

agent_generator_pkg/src/agent_generator/web/routes/pages.py

@@ -1,14 +1,13 @@
 """
 HTML page routes for the Agent Generator web UI -- 4-step wizard.
 
-Step 1: Describe (home)
-Step 2: Plan & Edit
-Step 3: Configure (framework, mode, tools)
-Step 4: Generate & Export
+Uses the production infrastructure:
+- PlanningService for spec creation
+- BuildService for code generation
+- SecurityValidator for artifact checks
 """
 from __future__ import annotations
 
-import ast
 import io
 import json
 import uuid
@@ -21,11 +20,9 @@ from fastapi import APIRouter, Form, HTTPException, Request
 from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
 from fastapi.templating import Jinja2Templates
 
-from agent_generator.config import Settings, get_settings_lenient
+from agent_generator.application.planning_service import plan as plan_spec
+from agent_generator.application.build_service import build_dict
 from agent_generator.frameworks import FRAMEWORKS
-from agent_generator.planners.keyword_planner import KeywordPlanner
-from agent_generator.utils.parser import parse_natural_language_to_workflow
-from agent_generator.utils.visualizer import to_mermaid
 from agent_generator.web.inference import (
     get_inference_client,
     get_inference_settings,
@@ -108,7 +105,6 @@ TOOL_CATEGORIES = {
 # Helpers
 # ---------------------------------------------------------------------------
 def _build_file_tree(files: dict) -> list:
-    """Build a hierarchical file tree from a flat dict of paths."""
     tree = []
     dirs_seen: set[str] = set()
     for filepath in sorted(files.keys()):
@@ -123,22 +119,15 @@ def _build_file_tree(files: dict) -> list:
 
 
 def _validate_files(files: dict[str, str]) -> list[dict]:
-    """Run basic validation on generated files.
-
-    Returns a list of {file, status, message} dicts.
-    """
+    import ast as _ast
     results = []
     for filepath, content in files.items():
         if filepath.endswith(".py"):
             try:
-                ast.parse(content, filename=filepath)
+                _ast.parse(content, filename=filepath)
                 results.append({"file": filepath, "status": "ok", "message": "Valid Python"})
             except SyntaxError as exc:
-                results.append({
-                    "file": filepath,
-                    "status": "error",
-                    "message": f"SyntaxError line {exc.lineno}: {exc.msg}",
-                })
+                results.append({"file": filepath, "status": "error", "message": f"SyntaxError line {exc.lineno}: {exc.msg}"})
         elif filepath.endswith((".yaml", ".yml")):
             try:
                 yaml.safe_load(content)
@@ -148,98 +137,39 @@ def _validate_files(files: dict[str, str]) -> list[dict]:
     return results
 
 
-def _merge_llm_plan(base_plan: dict, llm_plan: dict) -> dict:
-    """Merge an LLM-generated plan into the keyword-based plan.
-
-    The LLM plan is authoritative for agents/tasks/tools when present,
-    but we fall back to the keyword plan for any missing fields.
-    """
-    merged = dict(base_plan)
-    if llm_plan.get("name"):
-        merged["name"] = llm_plan["name"]
-    if llm_plan.get("description"):
-        merged["description"] = llm_plan["description"]
-    if llm_plan.get("framework") and llm_plan["framework"] in FRAMEWORK_LABELS:
-        merged["framework"] = llm_plan["framework"]
-    if llm_plan.get("agents"):
-        merged["agents"] = llm_plan["agents"]
-    if llm_plan.get("tasks"):
-        merged["tasks"] = llm_plan["tasks"]
-    if llm_plan.get("tools"):
-        merged["tools"] = llm_plan["tools"]
-    return merged
-
-
-def _keyword_plan(prompt: str) -> dict:
-    """Build a plan using the KeywordPlanner from the main project."""
-    planner = KeywordPlanner()
-    classification = planner.classify(prompt)
-
-    framework = classification.get("suggested_framework", "crewai")
-    if framework not in FRAMEWORKS:
-        framework = "crewai"
-
-    tools = classification.get("suggested_tools", [])
-    roles = classification.get("suggested_roles", [])
-    if not roles:
-        roles = ["assistant"]
-
-    import re
-    agents = []
-    for role in roles:
-        agents.append({
-            "id": role,
-            "role": role.replace("_", " ").title(),
-            "goal": f"Handle all {role}-related tasks effectively",
-            "backstory": f"An experienced {role} with deep domain expertise.",
-            "tools": tools[:2] if tools else [],
-        })
-
-    sentences = [s.strip() for s in re.split(r"[.!?]+", prompt) if s.strip() and len(s.strip()) > 5]
-    if not sentences:
-        sentences = [prompt.strip()]
-
-    tasks = []
-    for i, sentence in enumerate(sentences[:6]):
-        agent_idx = i % len(agents)
-        task_id = f"task_{i + 1}"
-        tasks.append({
-            "id": task_id,
-            "description": sentence,
-            "agent_id": agents[agent_idx]["id"],
-            "expected_output": f"Completed: {sentence[:80]}",
-            "depends_on": [f"task_{i}"] if i > 0 else [],
-        })
-
-    slug = re.sub(r"[^a-z0-9\s-]", "", prompt[:50].lower())
-    slug = re.sub(r"[\s_]+", "-", slug.strip())[:40] or "my-agent"
-
+def _spec_to_plan_dict(spec) -> dict:
+    """Convert a ProjectSpec to the dict format templates expect."""
     return {
-        "name": slug,
-        "description": prompt[:200],
-        "framework": framework,
-        "artifact_mode": "code_and_yaml",
-        "agents": agents,
-        "tasks": tasks,
-        "tools": [{"id": t, "template": t} for t in tools],
+        "name": spec.name,
+        "description": spec.description,
+        "framework": spec.framework.value,
+        "artifact_mode": spec.artifact_mode.value,
+        "agents": [a.model_dump() for a in spec.agents],
+        "tasks": [t.model_dump() for t in spec.tasks],
+        "tools": [t.model_dump() for t in spec.tools],
     }
 
 
+def _plan_and_build(prompt: str, framework: str = "auto",
+                    artifact_mode: str = "code_and_yaml") -> tuple[dict, dict[str, str]]:
+    """Use production pipeline to plan and build. Returns (plan_dict, files_dict)."""
+    fw = framework if framework != "auto" else None
+    spec, warnings = plan_spec(prompt, framework=fw)
+    result = build_dict(spec)
+    plan_dict = _spec_to_plan_dict(spec)
+    plan_dict["warnings"] = warnings + result.get("warnings", [])
+    return plan_dict, result.get("files", {})
+
+
 # ---------------------------------------------------------------------------
 # Routes -- Step 1: Describe
 # ---------------------------------------------------------------------------
 @router.get("/", response_class=HTMLResponse)
 async def home(request: Request):
-    """Step 1 -- prompt input with examples."""
     inference = get_inference_client()
     return templates.TemplateResponse(
-        request=request,
-        name="home.html",
-        context={
-            "request": request,
-            "examples": EXAMPLES,
-            "inference_available": inference.available,
-        },
+        request=request, name="home.html",
+        context={"request": request, "examples": EXAMPLES, "inference_available": inference.available},
     )
 
 
@@ -248,75 +178,42 @@ async def home(request: Request):
 # ---------------------------------------------------------------------------
 @router.post("/plan", response_class=HTMLResponse)
 async def plan(request: Request, prompt: str = Form(...)):
-    """Step 2 -- generate editable plan from prompt."""
     try:
-        # Keyword-based baseline
-        base_plan = _keyword_plan(prompt)
+        spec, warnings = plan_spec(prompt)
+        plan_data = _spec_to_plan_dict(spec)
 
-        # Try LLM enhancement
+        # Try LLM enhancement via inference client
         llm_enhanced = False
         inference = get_inference_client()
         if inference.available:
             llm_plan = inference.generate_plan(prompt)
             if llm_plan:
-                base_plan = _merge_llm_plan(base_plan, llm_plan)
+                for key in ("agents", "tasks", "tools"):
+                    if llm_plan.get(key):
+                        plan_data[key] = llm_plan[key]
                 llm_enhanced = True
 
         return templates.TemplateResponse(
-            request=request,
-            name="plan.html",
-            context={
-                "request": request,
-                "plan": base_plan,
-                "plan_json": json.dumps(base_plan, indent=2),
-                "prompt": prompt,
-                "llm_enhanced": llm_enhanced,
-                "frameworks": FRAMEWORK_LABELS,
-            },
+            request=request, name="plan.html",
+            context={"request": request, "plan": plan_data, "plan_json": json.dumps(plan_data, indent=2),
+                      "prompt": prompt, "llm_enhanced": llm_enhanced, "frameworks": FRAMEWORK_LABELS},
         )
     except Exception as e:
         return templates.TemplateResponse(
-            request=request,
-            name="home.html",
-            context={
-                "request": request,
-                "examples": EXAMPLES,
-                "error": f"Planning failed: {e}",
-                "inference_available": False,
-            },
+            request=request, name="home.html",
+            context={"request": request, "examples": EXAMPLES, "error": f"Planning failed: {e}", "inference_available": False},
         )
 
 
 @router.post("/edit-plan", response_class=JSONResponse)
 async def edit_plan(request: Request):
-    """AJAX endpoint -- re-plan with edits applied."""
     body = await request.json()
     prompt = body.get("prompt", "")
     edits = body.get("edits", "")
-    current_plan = body.get("current_plan", {})
-
-    combined_prompt = f"{prompt}. Additionally: {edits}" if edits else prompt
-
+    combined = f"{prompt}. Additionally: {edits}" if edits else prompt
     try:
-        base_plan = _keyword_plan(combined_prompt)
-
-        # Preserve framework choice from current plan if set
-        if current_plan.get("framework") and current_plan["framework"] != "auto":
-            base_plan["framework"] = current_plan["framework"]
-
-        inference = get_inference_client()
-        llm_enhanced = False
-        if inference.available:
-            llm_plan = inference.generate_plan(combined_prompt)
-            if llm_plan:
-                base_plan = _merge_llm_plan(base_plan, llm_plan)
-                llm_enhanced = True
-
-        return JSONResponse(content={
-            "ok": True,
-            "plan": base_plan,
-            "llm_enhanced": llm_enhanced,
-        })
+        spec, warnings = plan_spec(combined)
+        return JSONResponse(content={"ok": True, "plan": _spec_to_plan_dict(spec), "llm_enhanced": False})
     except Exception as e:
         return JSONResponse(content={"ok": False, "error": str(e)}, status_code=500)
 
@@ -325,60 +222,36 @@ async def edit_plan(request: Request):
 # Routes -- Step 3: Configure
 # ---------------------------------------------------------------------------
 @router.post("/configure", response_class=HTMLResponse)
-async def configure(
-    request: Request,
-    plan_json: str = Form(...),
-    prompt: str = Form(""),
-):
-    """Step 3 -- framework / mode / provider / tools configuration."""
+async def configure(request: Request, plan_json: str = Form(...), prompt: str = Form("")):
     try:
         plan_data = json.loads(plan_json)
     except json.JSONDecodeError:
         raise HTTPException(status_code=400, detail="Invalid plan JSON")
 
-    # Validate framework against FRAMEWORKS registry
-    fw = plan_data.get("framework", "crewai")
-    if fw not in FRAMEWORKS:
-        fw = "crewai"
-        plan_data["framework"] = fw
-
-    # Build a preview file tree using the real generator
-    preview_plan = dict(plan_data)
-    preview_plan.setdefault("artifact_mode", "code_and_yaml")
-
+    # Build preview using production infrastructure
     try:
-        settings = get_settings_lenient()
-        workflow = parse_natural_language_to_workflow(
-            preview_plan.get("description", "preview")
+        _, preview_files = _plan_and_build(
+            plan_data.get("description", "preview"),
+            plan_data.get("framework", "crewai"),
         )
-        generator_cls = FRAMEWORKS[fw]
-        generator = generator_cls()
-        code = generator.generate_code(workflow, settings, mcp=False)
-        preview_files = {"src/main.py": code}
-        if hasattr(generator, "generate_yaml"):
-            try:
-                yaml_code = generator.generate_yaml(workflow, settings)
-                preview_files["config/agents.yaml"] = yaml_code
-            except Exception:
-                pass
+        preview_tree = _build_file_tree(preview_files)
     except Exception:
-        preview_files = {"src/main.py": "# preview"}
+        preview_tree = []
 
-    preview_tree = _build_file_tree(preview_files)
+    tool_ids = []
+    for t in plan_data.get("tools", []):
+        if isinstance(t, dict):
+            tool_ids.append(t.get("id", ""))
+        elif isinstance(t, str):
+            tool_ids.append(t)
 
     return templates.TemplateResponse(
-        request=request,
-        name="configure.html",
+        request=request, name="configure.html",
         context={
-            "request": request,
-            "plan": plan_data,
-            "plan_json": json.dumps(plan_data),
-            "prompt": prompt,
-            "frameworks": FRAMEWORK_LABELS,
-            "framework_capabilities": FRAMEWORK_CAPABILITIES,
-            "tool_categories": TOOL_CATEGORIES,
-            "preview_tree": preview_tree,
-            "selected_tools": [t["id"] for t in plan_data.get("tools", [])],
+            "request": request, "plan": plan_data, "plan_json": json.dumps(plan_data),
+            "prompt": prompt, "frameworks": FRAMEWORK_LABELS,
+            "framework_capabilities": FRAMEWORK_CAPABILITIES, "tool_categories": TOOL_CATEGORIES,
+            "preview_tree": preview_tree, "selected_tools": tool_ids,
         },
     )
 
@@ -396,133 +269,60 @@ async def generate(
     provider: str = Form("watsonx"),
     tools: list[str] = Form(default=[]),
 ):
-    """Step 4 -- run generator, show results."""
     try:
         plan_data = json.loads(plan_json)
     except json.JSONDecodeError:
         raise HTTPException(status_code=400, detail="Invalid plan JSON")
 
-    # Apply config overrides
     if framework and framework != "auto":
         plan_data["framework"] = framework
-    plan_data["artifact_mode"] = artifact_mode
-
-    # Validate framework
-    fw = plan_data.get("framework", "crewai")
-    if fw not in FRAMEWORKS:
-        fw = "crewai"
-        plan_data["framework"] = fw
-
-    # Override tools if user changed selection
-    tool_list = [t for t in tools if t] if tools else None
-    if tool_list is not None:
-        plan_data["tools"] = [{"id": t, "template": t} for t in tool_list]
-        for agent in plan_data.get("agents", []):
-            agent["tools"] = tool_list[:2]
 
     try:
         effective_prompt = plan_data.get("description", prompt or "agent project")
-        settings = get_settings_lenient()
-        workflow = parse_natural_language_to_workflow(effective_prompt)
-
-        generator_cls = FRAMEWORKS[fw]
-        generator = generator_cls()
-        code = generator.generate_code(workflow, settings, mcp=False)
-
-        # Build file dict
-        project_name = plan_data.get("name", "agent-project")
-        files: dict[str, str] = {}
-
-        if artifact_mode in ("code_only", "code_and_yaml"):
-            files[f"src/{project_name}/main.py"] = code
-            files[f"src/{project_name}/__init__.py"] = f'"""Generated {project_name} package."""\n'
-            files["requirements.txt"] = _make_requirements(fw, provider)
-            files["README.md"] = _make_readme(project_name, plan_data.get("description", ""), fw)
-
-        if artifact_mode in ("yaml_only", "code_and_yaml"):
-            if hasattr(generator, "generate_yaml"):
-                try:
-                    yaml_code = generator.generate_yaml(workflow, settings)
-                    files[f"config/{project_name}.yaml"] = yaml_code
-                except Exception:
-                    pass
-            else:
-                files[f"config/{project_name}.yaml"] = yaml.dump({
-                    "name": project_name,
-                    "framework": fw,
-                    "agents": [{"role": a.get("role", ""), "goal": a.get("goal", "")} for a in plan_data.get("agents", [])],
-                }, default_flow_style=False)
-
-        # Merge back metadata from original plan
-        plan_result = dict(plan_data)
-        plan_result["name"] = plan_data.get("name", project_name)
-        plan_result["description"] = plan_data.get("description", "")
-        plan_result["framework"] = fw
-
-        # Validate
+        plan_result, files = _plan_and_build(effective_prompt, plan_data.get("framework", "crewai"), artifact_mode)
+
+        plan_result["name"] = plan_data.get("name", plan_result.get("name", "agent-project"))
+        plan_result["description"] = plan_data.get("description", plan_result.get("description", ""))
+
         validation = _validate_files(files)
         errors = [v for v in validation if v["status"] == "error"]
         ok_count = len([v for v in validation if v["status"] == "ok"])
 
-        # Store project
         project_id = str(uuid.uuid4())[:8]
         projects[project_id] = {"plan": plan_result, "files": files, "prompt": prompt}
 
         file_tree = _build_file_tree(files)
-        fw_label = FRAMEWORK_LABELS.get(plan_result["framework"], plan_result["framework"])
+        fw_label = FRAMEWORK_LABELS.get(plan_result.get("framework", ""), plan_result.get("framework", ""))
 
         return templates.TemplateResponse(
-            request=request,
-            name="result.html",
-            context={
-                "request": request,
-                "project_id": project_id,
-                "plan": plan_result,
-                "files": files,
-                "file_tree": file_tree,
-                "fw_label": fw_label,
-                "prompt": prompt,
-                "validation": validation,
-                "validation_errors": errors,
-                "validation_ok": ok_count,
-            },
+            request=request, name="result.html",
+            context={"request": request, "project_id": project_id, "plan": plan_result,
+                      "files": files, "file_tree": file_tree, "fw_label": fw_label,
+                      "prompt": prompt, "validation": validation,
+                      "validation_errors": errors, "validation_ok": ok_count},
         )
     except Exception as e:
         return templates.TemplateResponse(
-            request=request,
-            name="home.html",
-            context={
-                "request": request,
-                "examples": EXAMPLES,
-                "error": f"Generation failed: {e}",
-                "inference_available": False,
-            },
+            request=request, name="home.html",
+            context={"request": request, "examples": EXAMPLES, "error": f"Generation failed: {e}", "inference_available": False},
         )
 
 
 # ---------------------------------------------------------------------------
-# Routes -- Download & File Access
+# Routes -- Download
 # ---------------------------------------------------------------------------
 @router.get("/download/{project_id}")
-async def download_zip(project_id: str):
+async def download(project_id: str):
     if project_id not in projects:
-        raise HTTPException(status_code=404, detail="Project not found")
-
+        return JSONResponse({"error": "Project not found"}, status_code=404)
     project = projects[project_id]
-    files = project["files"]
-    name = project["plan"].get("name", "agent-project")
-
     buf = io.BytesIO()
     with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
-        for filepath, content in files.items():
-            zf.writestr(f"{name}/{filepath}", content)
+        for filepath, content in project["files"].items():
+            zf.writestr(f"{project['plan']['name']}/{filepath}", content)
     buf.seek(0)
-
-    return StreamingResponse(
-        buf,
-        media_type="application/zip",
-        headers={"Content-Disposition": f'attachment; filename="{name}.zip"'},
-    )
+    return StreamingResponse(buf, media_type="application/zip",
+                             headers={"Content-Disposition": f"attachment; filename={project['plan']['name']}.zip"})
 
 
 @router.get("/api/file/{project_id}/{filepath:path}")
@@ -533,48 +333,3 @@ async def get_file(project_id: str, filepath: str):
     if filepath not in project["files"]:
         return JSONResponse({"error": "File not found"}, status_code=404)
     return {"filepath": filepath, "content": project["files"][filepath]}
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-def _make_requirements(framework: str, provider: str) -> str:
-    lines = []
-    if framework in ("crewai", "crewai_flow"):
-        lines.append("crewai>=0.80.0")
-        lines.append("crewai-tools>=0.14.0")
-    elif framework == "langgraph":
-        lines.append("langgraph>=0.2.0")
-        lines.append("langchain>=0.3.0")
-        lines.append("langchain-community>=0.3.0")
-    elif framework == "react":
-        lines.append("langchain>=0.3.0")
-        lines.append("langchain-community>=0.3.0")
-    elif framework == "watsonx_orchestrate":
-        lines.append("ibm-watsonx-ai>=1.1.0")
-
-    if provider == "watsonx":
-        lines.append("ibm-watsonx-ai>=1.1.0")
-    elif provider == "openai":
-        lines.append("openai>=1.0.0")
-
-    lines.extend(["python-dotenv>=1.0.0", "pydantic>=2.0.0"])
-    return "\n".join(sorted(set(lines))) + "\n"
-
-
-def _make_readme(name: str, desc: str, framework: str) -> str:
-    return f"""# {name}
-
-{desc}
-
-## Framework
-{framework}
-
-## Quick Start
-```bash
-pip install -r requirements.txt
-python -m src.{name}.main
-```
-
-Generated by [Agent Generator](https://github.com/ruslanmv/agent-generator).
-"""