specsmith 0.12.0.dev494__tar.gz → 0.12.0.dev497__tar.gz

{specsmith-0.12.0.dev494/src/specsmith.egg-info → specsmith-0.12.0.dev497}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.12.0.dev494
+Version: 0.12.0.dev497
 Summary: Applied Epistemic Engineering toolkit — AEE agent sessions, execution profiles, FPGA/HDL governance, tool installer, 50+ CLI commands.
 Author: BitConcepts
 License-Expression: MIT

{specsmith-0.12.0.dev494 → specsmith-0.12.0.dev497}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsmith"
-version = "0.12.0.dev494"
+version = "0.12.0.dev497"
 description = "Applied Epistemic Engineering toolkit — AEE agent sessions, execution profiles, FPGA/HDL governance, tool installer, 50+ CLI commands."
 readme = "README.md"
 license = "MIT"

{specsmith-0.12.0.dev494 → specsmith-0.12.0.dev497}/src/specsmith/auditor.py

@@ -441,9 +441,11 @@ def check_ledger_health(root: Path) -> list[AuditResult]:
             )
         )
 
-    # Open TODOs
-    open_todos = sum(1 for line in lines if "- [ ]" in line)
-    closed_todos = sum(1 for line in lines if "- [x]" in line)
+    # Open TODOs — only count lines where the checklist marker is at the
+    # start of the trimmed line, not prose references such as:
+    #   "- TODO closure: all 109 - [ ] items changed to - [x]"
+    open_todos = sum(1 for line in lines if line.lstrip().startswith("- [ ]"))
+    closed_todos = sum(1 for line in lines if line.lstrip().startswith("- [x]"))
     if open_todos > 20:
         results.append(
             AuditResult(
@@ -715,8 +717,53 @@ def check_tool_configuration(root: Path) -> list[AuditResult]:
     return results
 
 
+# Types that require explicit configuration and cannot be reliably inferred
+# from file-extension counts alone.  When a project declares one of these,
+# auto-detection is skipped so that auxiliary tooling languages (e.g. Python
+# verification scripts in an FPGA project) do not produce a false-positive
+# mismatch.  See GitHub issue #194.
+_EXPLICIT_ONLY_TYPES: frozenset[str] = frozenset(
+    [
+        # Hardware / vendor-specific types that cannot be auto-detected from
+        # file extensions (Python/C tooling dominates file counts).
+        "fpga-rtl",
+        "fpga-rtl-amd",
+        "fpga-rtl-intel",
+        "fpga-rtl-lattice",
+        "mixed-fpga-embedded",
+        "mixed-fpga-firmware",
+        "embedded-hardware",
+        "pcb-hardware",
+        "yocto-bsp",
+        # Infrastructure types where auxiliary Python/JS glue code dominates
+        # and a generic detection pass would misclassify the primary type.
+        "kubernetes-operator",
+        "streaming-pipeline",
+        "serverless",
+        # AI / agent types: an LLM app is indistinguishable from a regular
+        # Python library unless dependency signals are present.  Suppress
+        # false-positive mismatches when the type is set explicitly.
+        "agent-orchestration",
+        "mcp-server",
+        "rag-pipeline",
+        "mlops-platform",
+        # Game engines: Unity / Godot projects often have Python tooling alongside.
+        "game-unity",
+        "game-godot",
+        # Data warehouse: dbt + SQL projects have no primary-language file bias.
+        "data-warehouse",
+    ]
+)
+
+
 def check_type_mismatch(root: Path) -> list[AuditResult]:
-    """Check if scaffold.yml type matches actual detected project type."""
+    """Check if scaffold.yml type matches actual detected project type.
+
+    For hardware / vendor-specific types that cannot be auto-detected from
+    file-extension counts (see ``_EXPLICIT_ONLY_TYPES``), the detection step
+    is skipped entirely so that auxiliary languages (e.g. Python scripts in an
+    FPGA project) never produce a false-positive mismatch.
+    """
     results: list[AuditResult] = []
     scaffold_path = root / "scaffold.yml"
     if not scaffold_path.exists():
@@ -731,6 +778,20 @@ def check_type_mismatch(root: Path) -> list[AuditResult]:
         with open(scaffold_path) as f:
             raw = yaml.safe_load(f)
         config = ProjectConfig(**raw)
+
+        # Skip auto-detection for types that must be specified explicitly.
+        if config.type in _EXPLICIT_ONLY_TYPES:
+            results.append(
+                AuditResult(
+                    name="type-mismatch",
+                    passed=True,
+                    message=(
+                        f"Project type {config.type} is explicitly set; auto-detection skipped"
+                    ),
+                )
+            )
+            return results
+
         detected = detect_project(root)
         if detected.inferred_type and detected.inferred_type != config.type:
             results.append(

{specsmith-0.12.0.dev494 → specsmith-0.12.0.dev497}/src/specsmith/cli.py

@@ -350,6 +350,16 @@ def init(config_path: str | None, output_dir: str, no_git: bool, guided: bool) -
 
     write_phase(target, "inception")
 
+    # Auto-register with the MCP governance server (best-effort, never blocks)
+    with contextlib.suppress(Exception):
+        from specsmith.mcp_server import register_project
+
+        if register_project(str(target)):
+            console.print(
+                "  [dim]\u2713 Registered with MCP server "
+                "([bold]specsmith mcp projects[/bold] to view)[/dim]"
+            )
+
 
 def _load_config_with_inheritance(config_path: str) -> dict[str, object]:
     """Load scaffold.yml, merging parent config if `extends` is set."""
@@ -1746,6 +1756,16 @@ def import_project(
     console.print(f"\n[bold green]Done.[/bold green] {len(created)} governance files generated.")
     console.print("Governance files generated. Review project configuration.")
 
+    # Auto-register with the MCP governance server (best-effort, never blocks)
+    with contextlib.suppress(Exception):
+        from specsmith.mcp_server import register_project
+
+        if register_project(str(root)):
+            console.print(
+                "  [dim]\u2713 Registered with MCP server "
+                "([bold]specsmith mcp projects[/bold] to view)[/dim]"
+            )
+
 
 def _run_guided_architecture(cfg: ProjectConfig, target: Path) -> list[Path]:
     """Run interactive architecture definition and generate REQ/TEST stubs."""
@@ -9049,46 +9069,44 @@ def mcp_list_cmd(project_dir: str, as_json: bool) -> None:
 
 
 @mcp_group.command(name="serve")
-@click.option("--project-dir", type=click.Path(), default=".", show_default=True)
+@click.option(
+    "--project-dir",
+    type=click.Path(),
+    default=None,
+    help=(
+        "Set this path as the *primary* project (first slot / default for tool calls "
+        "that omit project_dir). Omit to use the registry automatically."
+    ),
+)
 @click.option(
     "--project-dirs",
     default="",
     help=(
-        "Additional project directories to register (comma-separated absolute paths). "
-        "All registered projects are accessible to any tool call via their "
-        "absolute path as the project_dir argument."
+        "Extra project directories to add on top of the registry (comma-separated absolute paths)."
     ),
 )
-def mcp_serve_cmd(project_dir: str, project_dirs: str) -> None:
+def mcp_serve_cmd(project_dir: str | None, project_dirs: str) -> None:
     """Start the native governance MCP stdio server (REQ-363).
 
     Implements MCP 2024-11-05 over stdin/stdout (JSON-RPC 2.0).
-    Exposes seven governance tools to any MCP client:
+    Exposes seven governance tools to any MCP client.
 
     \b
-    governance_project_list List all registered projects
-    governance_audit        Run governance audit
-    governance_checkpoint   Emit GOVERNANCE ANCHOR JSON
-    governance_preflight    Preflight a change intent
-    governance_phase        Current AEE phase + readiness %
-    governance_req_list     List all requirements
-    governance_trace_seal   Seal a milestone/decision
+    Recommended Warp config (set once, never touch again)::
+
+        {"specsmith-governance": {"command": "specsmith", "args": ["mcp", "serve"]}}
 
     \b
-    Single-project Warp config (Settings → Agents → MCP servers)::
+    Then register each project once from inside that project::
 
-        {"specsmith-governance": {"command": "specsmith",
-         "args": ["mcp", "serve", "--project-dir", "/path/to/project"]}}
+        specsmith mcp register
 
     \b
-    Multi-project Warp config::
-
-        {"specsmith-governance": {"command": "specsmith",
-         "args": ["mcp", "serve", "--project-dir", "/path/to/proj1",
-                  "--project-dirs", "/path/to/proj2,/path/to/proj3"]}}
+    The server reads the registry at startup and serves all registered
+    projects automatically — no config changes needed for new projects.
 
     \b
-    Or pass inline to oz (use ``specsmith mcp install-warp`` for the full snippet)::
+    Or pass inline to oz (use ``specsmith mcp install-warp`` for the snippet)::
 
         oz agent run --mcp "$(specsmith mcp install-warp --json)" --prompt "..."
     """
@@ -9099,42 +9117,52 @@ def mcp_serve_cmd(project_dir: str, project_dirs: str) -> None:
 
 
 @mcp_group.command(name="install-warp")
-@click.option("--project-dir", type=click.Path(), default=".", show_default=True)
-@click.option(
-    "--project-dirs",
-    default="",
-    help="Additional project dirs (comma-separated) to include in the multi-project config.",
-)
 @click.option("--json", "as_json", is_flag=True, default=False, help="Emit JSON config only.")
-def mcp_install_warp_cmd(project_dir: str, project_dirs: str, as_json: bool) -> None:
+def mcp_install_warp_cmd(as_json: bool) -> None:
     """Print the Warp MCP config snippet for the governance server (REQ-363).
 
+    Generates a minimal, registry-aware config — paste it into Warp once
+    and never change it again.  Register new projects with::
+
+        specsmith mcp register          # in the project directory
+
     Copy the output into Warp Settings → Agents → MCP servers, or pass it
     to ``oz agent run --mcp '<json>'`` for a one-off cloud agent run.
-
-    For multi-project setups pass ``--project-dirs`` with comma-separated
-    absolute paths; one server instance will serve all projects.
     """
     import json as _json
     import shutil
     import sys
 
-    # Resolve the specsmith CLI executable: prefer the one on PATH, then
-    # fall back to deriving it from the current interpreter (dev installs).
-    specsmith_exe = shutil.which("specsmith") or str(
-        Path(sys.executable).parent / ("specsmith.exe" if sys.platform == "win32" else "specsmith")
-    )
-    default_dir = str(Path(project_dir).resolve())
-    args: list[str] = ["mcp", "serve", "--project-dir", default_dir]
+    # Env vars the server needs regardless of how it is invoked.
+    # SPECSMITH_ALLOW_NON_PIPX=1  — prevents the pipx-enforcement gate from
+    #   exiting before the MCP handshake when Warp starts the server directly.
+    # SPECSMITH_NO_AUTO_UPDATE / SPECSMITH_PYPI_CHECKED  — suppress network
+    #   calls on startup so the server responds immediately.
+    server_env = {
+        "SPECSMITH_ALLOW_NON_PIPX": "1",
+        "SPECSMITH_NO_AUTO_UPDATE": "1",
+        "SPECSMITH_PYPI_CHECKED": "1",
+    }
 
-    extra_dirs = [p.strip() for p in project_dirs.split(",") if p.strip()] if project_dirs else []
-    if extra_dirs:
-        args += ["--project-dirs", ",".join(extra_dirs)]
+    # Executable detection strategy (in priority order):
+    # 1. specsmith (or specsmith.exe) on PATH — covers pipx shims and system installs.
+    # 2. python -m specsmith via the current interpreter — reliable fallback
+    #    for editable dev installs and venvs where the console script wrapper
+    #    is absent or resolves incorrectly (e.g. some Windows pipx setups).
+    specsmith_exe = shutil.which("specsmith") or shutil.which("specsmith.exe")
+    if specsmith_exe:
+        cmd = specsmith_exe
+        args: list[str] = ["mcp", "serve"]
+    else:
+        # Fall back to `python -m specsmith` using the current interpreter.
+        cmd = sys.executable
+        args = ["-m", "specsmith", "mcp", "serve"]
 
     config = {
         "specsmith-governance": {
-            "command": specsmith_exe,
+            "command": cmd,
             "args": args,
+            "env": server_env,
         }
     }
 
@@ -9148,22 +9176,124 @@ def mcp_install_warp_cmd(project_dir: str, project_dirs: str, as_json: bool) ->
         "or pass inline to [bold]oz agent run --mcp '<json>'[/bold]:\n"
     )
     console.print(_json.dumps(config, indent=2))
-    if extra_dirs:
-        console.print(
-            f"\n[dim]Serving {1 + len(extra_dirs)} projects. "
-            "Call [bold]governance_project_list[/bold] to see all registered paths,\n"
-            "then pass any path as [bold]project_dir[/bold] to target a specific project.[/dim]"
-        )
+    console.print(
+        "\n[dim][bold]One-time setup[/bold] — paste this config into Warp once,"  # noqa: E501
+        " then never touch it again.\n"
+        "\nTo add each project, run this inside the project directory:\n"
+        "  [bold]specsmith mcp register[/bold]\n"
+        "\nThe server reads [bold]~/.specsmith/mcp-projects.json[/bold] at startup\n"
+        "and serves all registered projects automatically.\n"
+        "\nView registered projects: [bold]specsmith mcp projects[/bold]\n"
+        "\nVerify server: specsmith mcp serve (then send an initialize message).[/dim]"
+    )
+
+
+@mcp_group.command(name="register")
+@click.argument("path", default=".", required=False)
+def mcp_register_cmd(path: str) -> None:
+    """Register a project directory with the MCP server registry.
+
+    Run once inside a project directory to add it to
+    ``~/.specsmith/mcp-projects.json``.  The next ``specsmith mcp serve``
+    invocation will automatically include it — no Warp config changes needed.
+
+    \b
+    Examples::
+
+        specsmith mcp register          # register current directory
+        specsmith mcp register /path/to/myproject
+    """
+    from specsmith.mcp_server import register_project
+
+    root = Path(path).resolve()
+    if not root.exists():
+        console.print(f"[red]\u2717[/red] Path does not exist: {root}")
+        raise SystemExit(1)
+
+    added = register_project(str(root))
+    if added:
+        console.print(f"[green]\u2713[/green] Registered: [bold]{root}[/bold]")
+        if not (root / ".specsmith").exists():
+            console.print(
+                "  [yellow]\u26a0[/yellow] No .specsmith/ found. "
+                "Run [bold]specsmith init[/bold] or [bold]specsmith import[/bold] first."
+            )
     else:
+        console.print(f"[dim]Already registered: {root}[/dim]")
+    console.print(
+        "  [dim]specsmith mcp projects  ← view all registered[/dim]\n"
+        "  [dim]specsmith mcp serve      ← start the server[/dim]"
+    )
+
+
+@mcp_group.command(name="unregister")
+@click.argument("path", default=".", required=False)
+def mcp_unregister_cmd(path: str) -> None:
+    """Remove a project directory from the MCP server registry.
+
+    \b
+    Examples::
+
+        specsmith mcp unregister          # unregister current directory
+        specsmith mcp unregister /path/to/myproject
+    """
+    from specsmith.mcp_server import unregister_project
+
+    root = Path(path).resolve()
+    removed = unregister_project(str(root))
+    if removed:
+        console.print(f"[green]\u2713[/green] Unregistered: [bold]{root}[/bold]")
+    else:
+        console.print(f"[yellow]Not registered: {root}[/yellow]")
+
+
+@mcp_group.command(name="projects")
+@click.option("--json", "as_json", is_flag=True, default=False, help="Emit as JSON.")
+def mcp_projects_cmd(as_json: bool) -> None:
+    """List all projects registered with the MCP server.
+
+    Shows each registered project path and whether it still exists on disk.
+    The first entry is the default (used when a tool call omits project_dir).
+    """
+    import json as _json
+    import os
+
+    from specsmith.mcp_server import _registry_file, read_registry
+
+    projects = read_registry()
+    reg_path = _registry_file()
+
+    if as_json:
+        entries = [
+            {"path": p, "exists": Path(p).exists(), "is_default": i == 0}
+            for i, p in enumerate(projects)
+        ]
+        click.echo(_json.dumps({"registry": str(reg_path), "projects": entries}, indent=2))
+        return
+
+    if not projects:
+        console.print("[yellow]No projects registered.[/yellow]")
         console.print(
-            "\n[dim]After adding, Warp/Oz can call governance_project_list, "
-            "governance_audit, governance_preflight,\n"
-            "governance_checkpoint, governance_phase, governance_req_list, and\n"
-            "governance_trace_seal as structured MCP tool calls.\n"
-            "\nFor multiple projects add --project-dirs /path/a,/path/b to serve them "
-            "all from one server instance.\n"
-            "\nVerify with: specsmith mcp serve (then send an initialize message).[/dim]"
+            "[dim]Run [bold]specsmith mcp register[/bold] inside a project to add it.[/dim]"
         )
+        return
+
+    console.print(
+        f"[bold]Registered MCP projects[/bold] ({len(projects)})  [dim]{reg_path}[/dim]\n"
+    )
+    for i, p in enumerate(projects):
+        exists = Path(p).exists()
+        default_tag = "  [bold cyan][default][/bold cyan]" if i == 0 else ""
+        health = "[green]\u2713 exists[/green]" if exists else "[red]\u2717 not found[/red]"
+        # Abbreviate long paths using ~ for home
+        display = p.replace(os.path.expanduser("~"), "~")
+        console.print(f"  {health}  {display}{default_tag}")
+
+    console.print(
+        "\n[dim]  specsmith mcp register [path]    ← add a project"
+        "\n  specsmith mcp unregister [path]  ← remove a project"
+        "\n  specsmith mcp serve              ← start the server[/dim]"
+    )
 
 
 main.add_command(mcp_group)

{specsmith-0.12.0.dev494 → specsmith-0.12.0.dev497}/src/specsmith/config.py

@@ -74,6 +74,28 @@ class ProjectType(str, Enum):
     SVELTEKIT_APP = "sveltekit-app"  # SvelteKit app
     REMIX_APP = "remix-app"  # Remix full-stack React app
     ASTRO_SITE = "astro-site"  # Astro static/SSR site
+    # AI / LLM / Agents
+    LLM_APP = "llm-app"  # LLM-powered app (LangChain / LlamaIndex / custom SDK)
+    AGENT_ORCHESTRATION = "agent-orchestration"  # Multi-agent system (AutoGen/CrewAI/LangGraph)
+    MCP_SERVER = "mcp-server"  # Model Context Protocol server
+    RAG_PIPELINE = "rag-pipeline"  # RAG + embedding pipeline
+    MLOPS_PLATFORM = "mlops-platform"  # MLOps platform (MLflow / BentoML / Ray Serve)
+    # JVM
+    JAVA_SPRING = "java-spring"  # Spring Boot application
+    JAVA_LIBRARY = "java-library"  # Java library / SDK
+    # Cloud / Infrastructure
+    SERVERLESS = "serverless"  # FaaS (Lambda / GCP Functions / Cloudflare Workers)
+    KUBERNETES_OPERATOR = "kubernetes-operator"  # K8s controller / operator
+    STREAMING_PIPELINE = "streaming-pipeline"  # Kafka / Flink / Beam / Spark Streaming
+    DATA_WAREHOUSE = "data-warehouse"  # dbt / Snowflake / BigQuery / Redshift
+    # Game development
+    GAME_UNITY = "game-unity"  # Unity game project
+    GAME_GODOT = "game-godot"  # Godot game project
+    # Web3 / blockchain
+    SMART_CONTRACT = "smart-contract"  # Solidity / EVM smart contracts
+    # Desktop
+    DESKTOP_ELECTRON = "desktop-electron"  # Electron desktop app
+    DESKTOP_TAURI = "desktop-tauri"  # Tauri desktop app (Rust + WebView)
 
 
 class Platform(str, Enum):
@@ -548,6 +570,28 @@ _TYPE_LABELS: dict[str, str] = {
     ProjectType.SVELTEKIT_APP: "SvelteKit application",
     ProjectType.REMIX_APP: "Remix application (React + full-stack)",
     ProjectType.ASTRO_SITE: "Astro site (static / SSR)",
+    # AI / LLM / Agents
+    ProjectType.LLM_APP: "LLM-powered application (LangChain / LlamaIndex / custom)",
+    ProjectType.AGENT_ORCHESTRATION: "Multi-agent orchestration (AutoGen / CrewAI / LangGraph)",
+    ProjectType.MCP_SERVER: "MCP server (Model Context Protocol)",
+    ProjectType.RAG_PIPELINE: "RAG / embedding pipeline",
+    ProjectType.MLOPS_PLATFORM: "MLOps platform (MLflow / BentoML / Ray Serve)",
+    # JVM
+    ProjectType.JAVA_SPRING: "Java Spring Boot application",
+    ProjectType.JAVA_LIBRARY: "Java library / SDK",
+    # Cloud / Infrastructure
+    ProjectType.SERVERLESS: "Serverless / FaaS (Lambda / GCP Functions / Cloudflare Workers)",
+    ProjectType.KUBERNETES_OPERATOR: "Kubernetes operator / controller",
+    ProjectType.STREAMING_PIPELINE: "Streaming data pipeline (Kafka / Flink / Beam)",
+    ProjectType.DATA_WAREHOUSE: "Data warehouse (dbt / Snowflake / BigQuery)",
+    # Game development
+    ProjectType.GAME_UNITY: "Game (Unity)",
+    ProjectType.GAME_GODOT: "Game (Godot)",
+    # Web3
+    ProjectType.SMART_CONTRACT: "Smart contract (Solidity / EVM)",
+    # Desktop
+    ProjectType.DESKTOP_ELECTRON: "Desktop application (Electron)",
+    ProjectType.DESKTOP_TAURI: "Desktop application (Tauri — Rust + WebView)",
 }
 
 _SECTION_REFS: dict[str, str] = {
@@ -584,4 +628,26 @@ _SECTION_REFS: dict[str, str] = {
     ProjectType.EPISTEMIC_PIPELINE: "17.31",
     ProjectType.KNOWLEDGE_ENGINEERING: "17.32",
     ProjectType.AEE_RESEARCH: "17.33",
+    # AI / LLM / Agents
+    ProjectType.LLM_APP: "17.34",
+    ProjectType.AGENT_ORCHESTRATION: "17.35",
+    ProjectType.MCP_SERVER: "17.36",
+    ProjectType.RAG_PIPELINE: "17.37",
+    ProjectType.MLOPS_PLATFORM: "17.38",
+    # JVM
+    ProjectType.JAVA_SPRING: "17.39",
+    ProjectType.JAVA_LIBRARY: "17.40",
+    # Cloud / Infrastructure
+    ProjectType.SERVERLESS: "17.41",
+    ProjectType.KUBERNETES_OPERATOR: "17.42",
+    ProjectType.STREAMING_PIPELINE: "17.43",
+    ProjectType.DATA_WAREHOUSE: "17.44",
+    # Game development
+    ProjectType.GAME_UNITY: "17.45",
+    ProjectType.GAME_GODOT: "17.46",
+    # Web3
+    ProjectType.SMART_CONTRACT: "17.47",
+    # Desktop
+    ProjectType.DESKTOP_ELECTRON: "17.48",
+    ProjectType.DESKTOP_TAURI: "17.49",
 }

{specsmith-0.12.0.dev494 → specsmith-0.12.0.dev497}/src/specsmith/importer.py

@@ -1142,15 +1142,81 @@ def _infer_type(result: DetectionResult) -> ProjectType:
             pkg = result.root / "package.json"
             if pkg.exists():
                 content = pkg.read_text(encoding="utf-8")
+                if "electron" in content:
+                    return ProjectType.DESKTOP_ELECTRON
+                if "solidity" in content or "hardhat" in content or "ethers" in content:
+                    return ProjectType.SMART_CONTRACT
+                if (result.root / "serverless.yml").exists() or (
+                    result.root / "wrangler.toml"
+                ).exists():
+                    return ProjectType.SERVERLESS
                 if "react" in content or "vue" in content or "angular" in content:
                     # Check if there's also a server
                     if (result.root / "server").exists() or "express" in content:
                         return ProjectType.FULLSTACK_JS
                     return ProjectType.WEB_FRONTEND
+        # Tauri: has src-tauri/
+        if (result.root / "src-tauri").is_dir():
+            return ProjectType.DESKTOP_TAURI
         return ProjectType.FULLSTACK_JS
 
+    # Data warehouse: dbt_project.yml is a strong signal
+    if (result.root / "dbt_project.yml").exists():
+        return ProjectType.DATA_WAREHOUSE
+    # Kubernetes operator: Go + controllers/ dir
+    if lang == "go" and (result.root / "controllers").is_dir():
+        return ProjectType.KUBERNETES_OPERATOR
+    # Serverless: serverless.yml or SAM template.yaml or wrangler.toml
+    if (
+        (result.root / "serverless.yml").exists()
+        or (result.root / "serverless.yaml").exists()
+        or (result.root / "wrangler.toml").exists()
+    ):
+        return ProjectType.SERVERLESS
     # Python types
     if lang == "python":
+        # Detect AI / agent project types from dependencies before build-system checks
+        _req_text = ""
+        for _rf in (
+            result.root / "requirements.txt",
+            result.root / "pyproject.toml",
+        ):
+            if _rf.exists():
+                _req_text += _rf.read_text(encoding="utf-8", errors="ignore").lower()
+        _mcp_indicators = {"mcp", "model-context-protocol", "fastmcp", "modelcontextprotocol"}
+        _agent_orch_indicators = {"autogen", "crewai", "langgraph", "swarm", "ag2", "pyautogen"}
+        _llm_indicators = {
+            "langchain",
+            "llama-index",
+            "llama_index",
+            "haystack",
+            "openai",
+            "anthropic",
+            "litellm",
+        }
+        _rag_indicators = {
+            "chromadb",
+            "faiss",
+            "pinecone",
+            "weaviate",
+            "qdrant",
+            "pgvector",
+            "llama-index",
+        }
+        _mlops_indicators = {"mlflow", "bentoml", "ray", "kubeflow", "prefect", "airflow"}
+        _streaming_indicators = {"kafka", "flink", "pyflink", "apache-beam", "pyspark"}
+        if any(ind in _req_text for ind in _mcp_indicators):
+            return ProjectType.MCP_SERVER
+        if any(ind in _req_text for ind in _agent_orch_indicators):
+            return ProjectType.AGENT_ORCHESTRATION
+        if any(ind in _req_text for ind in _rag_indicators):
+            return ProjectType.RAG_PIPELINE
+        if any(ind in _req_text for ind in _mlops_indicators):
+            return ProjectType.MLOPS_PLATFORM
+        if any(ind in _req_text for ind in _streaming_indicators):
+            return ProjectType.STREAMING_PIPELINE
+        if any(ind in _req_text for ind in _llm_indicators):
+            return ProjectType.LLM_APP
         if build in ("pyproject", "setuptools"):
             # Check for CLI entry point
             if any("cli.py" in e for e in result.entry_points):