specsmith 0.19.2.dev738__tar.gz → 0.19.2.dev739__tar.gz

{specsmith-0.19.2.dev738/src/specsmith.egg-info → specsmith-0.19.2.dev739}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.19.2.dev738
+Version: 0.19.2.dev739
 Summary: AEE governance toolkit for AI-assisted development — session preflight gates, multi-agent dispatch, requirements↔test traceability, ESDB persistence, MCP server, and skills for Warp, Cursor, Claude Code, Copilot, Windsurf, and Aider.
 Author: Layer1Labs Silicon, Inc.
 License-Expression: MIT

{specsmith-0.19.2.dev738 → specsmith-0.19.2.dev739}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsmith"
-version = "0.19.2.dev738"
+version = "0.19.2.dev739"
 description = "AEE governance toolkit for AI-assisted development — session preflight gates, multi-agent dispatch, requirements↔test traceability, ESDB persistence, MCP server, and skills for Warp, Cursor, Claude Code, Copilot, Windsurf, and Aider."
 readme = "README.md"
 license = "MIT"

{specsmith-0.19.2.dev738 → specsmith-0.19.2.dev739}/src/specsmith/agent/runner.py

@@ -304,6 +304,12 @@ class AgentRunner:
         self.endpoint_id = (endpoint_id or "").strip() or None
         self.profile_id = (profile_id or "").strip() or None
 
+        # Host-terminal detection (REQ-444): when running inside Warp the
+        # banner/ready frame advertises native integration. Read-only.
+        from specsmith.agent.terminal_env import detect_terminal
+
+        self.terminal = detect_terminal()
+
         # Use a plain-text emitter in interactive mode so LLM tokens render
         # as readable prose instead of raw JSONL frames on the terminal.
         if emitter is not None:
@@ -374,6 +380,7 @@ class AgentRunner:
                 profile_id=self.profile_id or "",
                 capabilities=_capabilities(),
                 endpoint_id=self.endpoint_id or "",
+                terminal=self.terminal.as_dict(),
             )
         else:
             statuses = check_providers()
@@ -385,6 +392,9 @@ class AgentRunner:
                 "",
                 "  LLM providers:",
             ]
+            if self.terminal.is_warp:
+                ver = f" {self.terminal.version}" if self.terminal.version else ""
+                lines.insert(3, f"  terminal: Warp{ver} \u2014 native integration active")
             for s in statuses:
                 if s.available:
                     lines.append(

specsmith-0.19.2.dev739/src/specsmith/agent/terminal_env.py

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 Layer1Labs Silicon, Inc. All rights reserved.
+"""Terminal-environment detection for specsmith (REQ-444).
+
+Lets the interactive REPL (``specsmith run``) detect when it is running
+inside Warp so it can adapt its banner / ``ready`` frame.  Detection is
+based on the standard ``TERM_PROGRAM`` signal Warp sets, plus any
+``WARP_*`` environment variables, and is purely read-only.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import asdict, dataclass
+
+
+@dataclass(frozen=True)
+class TerminalInfo:
+    """Information about the host terminal."""
+
+    is_warp: bool
+    program: str
+    version: str
+
+    def as_dict(self) -> dict[str, object]:
+        """Return a flat dict suitable for the ``ready`` event frame."""
+        return asdict(self)
+
+
+def detect_terminal(env: dict[str, str] | None = None) -> TerminalInfo:
+    """Detect the host terminal from environment variables.
+
+    Warp sets ``TERM_PROGRAM=WarpTerminal`` (and ``TERM_PROGRAM_VERSION``).
+    As a fallback we also treat the presence of any ``WARP_*`` variable as a
+    Warp signal.  Pass *env* to override ``os.environ`` (used by tests).
+    """
+    source = os.environ if env is None else env
+    program = (source.get("TERM_PROGRAM") or "").strip()
+    version = (source.get("TERM_PROGRAM_VERSION") or "").strip()
+    is_warp = program == "WarpTerminal" or any(k.startswith("WARP_") for k in source)
+    if is_warp and not program:
+        program = "WarpTerminal"
+    return TerminalInfo(is_warp=is_warp, program=program, version=version)

{specsmith-0.19.2.dev738 → specsmith-0.19.2.dev739}/src/specsmith/cli.py

@@ -5625,12 +5625,14 @@ def integrate_cmd(tool_name: str, project_dir: str, dry_run: bool) -> None:
     what belief artifacts this tool provides evidence for, what its
     uncertainty bounds are, and what failure modes it might introduce.
     """
+    from specsmith.paths import find_requirements, find_scaffold
+
     root = Path(project_dir).resolve()
-    req_path = root / "docs" / "REQUIREMENTS.md"
+    req_path = find_requirements(root)
 
     console.print(f"[bold]Epistemic Impact Analysis[/bold]: {tool_name}\n")
 
-    if req_path.exists():
+    if req_path is not None:
         from specsmith.epistemic.belief import parse_requirements_as_beliefs
 
         artifacts = parse_requirements_as_beliefs(req_path)
@@ -5669,19 +5671,23 @@ def integrate_cmd(tool_name: str, project_dir: str, dry_run: bool) -> None:
         from specsmith.integrations import get_adapter
 
         adapter = get_adapter(tool_name)
-        scaffold_path = root / "scaffold.yml"
-        if scaffold_path.exists():
+        scaffold_file = find_scaffold(root)
+        if scaffold_file is not None:
             import yaml
 
-            with open(scaffold_path) as f:
+            from specsmith.config import _normalize_scaffold_raw
+
+            with open(scaffold_file) as f:
                 raw = yaml.safe_load(f)
-            config = ProjectConfig(**raw)
+            config = ProjectConfig(**_normalize_scaffold_raw(raw or {}))
             created = adapter.generate(config, root)
             for path in created:
                 console.print(f"  [green]✓[/green] {path.relative_to(root)}")
             console.print(f"\n[bold green]{len(created)} adapter file(s) generated.[/bold green]")
         else:
-            console.print("[yellow]No scaffold.yml found. Run specsmith import first.[/yellow]")
+            console.print(
+                "[yellow]No docs/SPECSMITH.yml found. Run specsmith import first.[/yellow]"
+            )
     except ValueError:
         console.print(
             f"[yellow]No built-in adapter for '{tool_name}'.[/yellow] "
@@ -10592,41 +10598,10 @@ def mcp_install_warp_cmd(as_json: bool) -> None:
     to ``oz agent run --mcp '<json>'`` for a one-off cloud agent run.
     """
     import json as _json
-    import shutil
-    import sys
 
-    # 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",
-    }
+    from specsmith.mcp_server import build_warp_mcp_config
 
-    # 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": cmd,
-            "args": args,
-            "env": server_env,
-        }
-    }
+    config = build_warp_mcp_config()
 
     if as_json:
         click.echo(_json.dumps(config, indent=2))
@@ -14152,6 +14127,55 @@ def local_model_detect_cmd(as_json: bool) -> None:
     )
 
 
+@local_model_group.command(name="recommend")
+@click.option("--json", "as_json", is_flag=True, default=False, help="Emit result as JSON.")
+def local_model_recommend_cmd(as_json: bool) -> None:
+    """Recommend a full local model lineup based on detected GPU VRAM (REQ-445).
+
+    Detects the host GPU and prints a VRAM-aware role lineup (default / fast /
+    harder pass / general) with a per-model fit assessment so you can see which
+    models run fully on the GPU and which would spill to system RAM.
+    """
+    import json as _json
+
+    from specsmith.local_model import recommend_for_hardware
+
+    lineup = recommend_for_hardware()
+
+    if as_json:
+        click.echo(
+            _json.dumps(
+                lineup.as_dict()
+                if lineup is not None
+                else {"hardware": None, "reason": "cpu-only or insufficient VRAM", "models": []}
+            )
+        )
+        return
+
+    if lineup is None:
+        console.print(
+            "[yellow]\u2014[/yellow] No GPU / insufficient VRAM detected. "
+            "Local model recommendations skipped (CPU-only would be too slow)."
+        )
+        return
+
+    console.print(
+        f"[bold]Hardware:[/bold] {lineup.hardware}  ([bold]{lineup.vram_gb:.1f} GB[/bold] VRAM)\n"
+    )
+    _fit_color = {"fits": "green", "tight": "yellow", "spills": "red"}
+    for rec in lineup.models:
+        color = _fit_color.get(rec.fit.value, "white")
+        console.print(
+            f"  [bold]{rec.slot:<8}[/bold] [green]{rec.model:<22}[/green] "
+            f"~{rec.footprint_gb:.1f} GB  [{color}]{rec.fit_note}[/{color}]"
+        )
+        console.print(f"           [dim]{rec.summary}[/dim]")
+    console.print(
+        "\n[dim]Pull all with [bold]specsmith local-model setup[/bold], or pull one with "
+        "[bold]ollama pull <model>[/bold].[/dim]"
+    )
+
+
 @local_model_group.command(name="setup")
 def local_model_setup_cmd() -> None:
     """Pull the recommended local model via Ollama (REQ-386).

{specsmith-0.19.2.dev738 → specsmith-0.19.2.dev739}/src/specsmith/integrations/__init__.py

@@ -15,12 +15,11 @@ ADAPTER_REGISTRY: dict[str, type[AgentAdapter]] = {}
 # canonical name. Lookups for legacy keys still succeed (backward compat for
 # existing scaffold.yml files) but only the canonical names are returned by
 # ``list_adapters()``.
-LEGACY_ALIASES: dict[str, str] = {
-    # Pre-0.5.0 the agent-skill adapter shipped under the name ``warp`` and
-    # wrote to ``.warp/skills/SKILL.md``. New scaffolds use ``agent-skill``
-    # and ``.agents/skills/SKILL.md``.
-    "warp": "agent-skill",
-}
+#
+# Note: ``warp`` is no longer an alias — it now resolves to the dedicated
+# :class:`~specsmith.integrations.warp.WarpAdapter`, which still emits the
+# governance skill (via ``AgentSkillAdapter``) plus Warp-native artifacts.
+LEGACY_ALIASES: dict[str, str] = {}
 
 
 def _load_adapters() -> None:
@@ -32,6 +31,7 @@ def _load_adapters() -> None:
     from specsmith.integrations.copilot import CopilotAdapter
     from specsmith.integrations.cursor import CursorAdapter
     from specsmith.integrations.gemini import GeminiAdapter
+    from specsmith.integrations.warp import WarpAdapter
     from specsmith.integrations.windsurf import WindsurfAdapter
 
     for cls in (
@@ -43,6 +43,7 @@ def _load_adapters() -> None:
         GeminiAdapter,
         WindsurfAdapter,
         AiderAdapter,
+        WarpAdapter,
     ):
         ADAPTER_REGISTRY[cls().name] = cls
 

specsmith-0.19.2.dev739/src/specsmith/integrations/warp.py

@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 Layer1Labs Silicon, Inc. All rights reserved.
+"""Warp integration adapter (REQ-444).
+
+Generates Warp-native artifacts so Warp's agent is governed by specsmith:
+
+  * ``.warp/specsmith-mcp.json``                      — governance MCP server config
+  * ``.warp/launch_configs/specsmith-governed.yaml``  — launch config for a governed session
+  * ``.agents/skills/SKILL.md``                       — governance skill (shared with agent-skill)
+
+``AGENTS.md`` is already the governance hub Warp reads as project Rules, so the
+adapter does not duplicate it.
+
+This adapter supersedes the pre-0.5.0 ``warp`` name that previously aliased to
+the generic ``agent-skill`` adapter; the skill is still emitted here (by reusing
+``AgentSkillAdapter``), so existing setups keep their ``.agents/skills/SKILL.md``.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from specsmith.config import ProjectConfig
+from specsmith.integrations.agent_skill import AgentSkillAdapter
+from specsmith.integrations.base import AgentAdapter
+
+
+class WarpAdapter(AgentAdapter):
+    """Generate Warp-native governance integration files."""
+
+    @property
+    def name(self) -> str:
+        return "warp"
+
+    @property
+    def description(self) -> str:
+        return "Warp native integration (MCP server config, launch config, governance skill)"
+
+    def generate(self, config: ProjectConfig, target: Path) -> list[Path]:
+        created: list[Path] = []
+        warp_dir = target / ".warp"
+        warp_dir.mkdir(parents=True, exist_ok=True)
+
+        # 1. MCP governance server config (shared builder with `mcp install-warp`).
+        from specsmith.mcp_server import build_warp_mcp_config
+
+        mcp_path = warp_dir / "specsmith-mcp.json"
+        mcp_path.write_text(
+            json.dumps(build_warp_mcp_config(), indent=2) + "\n",
+            encoding="utf-8",
+        )
+        created.append(mcp_path)
+
+        # 2. Launch config for a governed `specsmith run` session.
+        launch_dir = warp_dir / "launch_configs"
+        launch_dir.mkdir(parents=True, exist_ok=True)
+        launch_path = launch_dir / "specsmith-governed.yaml"
+        launch_path.write_text(self._render_launch_config(config, target), encoding="utf-8")
+        created.append(launch_path)
+
+        # 3. Governance skill (reuse the agent-skill adapter; .agents/skills/SKILL.md).
+        created.extend(AgentSkillAdapter().generate(config, target))
+
+        return created
+
+    def _render_launch_config(self, config: ProjectConfig, target: Path) -> str:
+        cwd = str(target).replace("\\", "/")
+        return f"""\
+# specsmith governed session — Warp launch configuration.
+# Copy to your Warp launch configurations directory to use it:
+#   macOS/Linux: ~/.warp/launch_configurations/
+#   Windows:     %APPDATA%/warp/Warp/data/launch_configurations/
+# The governance MCP server config lives in .warp/specsmith-mcp.json — add it
+# under Warp Settings -> Agents -> MCP servers so Warp's agent is governed.
+name: {config.name} — specsmith governed
+windows:
+  - tabs:
+      - title: specsmith
+        layout:
+          cwd: "{cwd}"
+          commands:
+            - exec: specsmith run
+"""

{specsmith-0.19.2.dev738 → specsmith-0.19.2.dev739}/src/specsmith/local_model.py

@@ -76,6 +76,9 @@ _REASON_14B = "deepseek-r1:14b"
 _REASON_8B = "deepseek-r1:8b"
 _REASON_7B = "deepseek-r1:7b"
 
+# ── Heavier coder for the "harder pass" slot (deepseek-coder-v2, MoE) ───────
+_DEEPSEEK_CODER_V2 = "deepseek-coder-v2:16b"
+
 
 @dataclass
 class LocalModelInfo:
@@ -394,6 +397,209 @@ def detect_local_model() -> LocalModelInfo | None:
     return None
 
 
+# ---------------------------------------------------------------------------
+# VRAM-aware recommendation engine (REQ-445)
+# ---------------------------------------------------------------------------
+#
+# ``recommend_models`` turns a detected VRAM figure into a complete, first-class
+# role lineup with per-model fit assessment, so recommendations always follow
+# the GPU that was actually detected. ``recommend_for_hardware`` is the
+# top-level entry point: it detects the host GPU (Apple Silicon or NVIDIA) and
+# applies the same VRAM tiering used by ``detect_local_models``.
+
+# Approximate on-GPU footprint (GB) for each model at its default Ollama
+# quantization (Q4_K_M for dense models; MoE active-params for deepseek-coder-v2).
+# Used purely to assess fit against detected VRAM — not an exact figure.
+_MODEL_FOOTPRINT_GB: dict[str, float] = {
+    _MODEL_7B: 4.7,
+    _MODEL_14B: 9.0,
+    _MODEL_32B: 20.0,
+    _GEN_7B: 4.7,
+    _GEN_14B: 9.0,
+    _GEN_32B: 20.0,
+    _REASON_7B: 4.7,
+    _REASON_8B: 5.2,
+    _REASON_14B: 9.0,
+    _DEEPSEEK_CODER_V2: 8.9,
+}
+
+# Headroom (GB) reserved above a model's footprint for the KV cache / context.
+_FIT_HEADROOM_GB = 2.0
+
+
+class ModelFit(str, Enum):
+    """How well a model fits the detected VRAM."""
+
+    fits = "fits"  # footprint + headroom <= VRAM → fully on GPU
+    tight = "tight"  # footprint <= VRAM < footprint + headroom
+    spills = "spills"  # footprint > VRAM → partial CPU offload (slow)
+
+
+_FIT_NOTE: dict[ModelFit, str] = {
+    ModelFit.fits: "fits fully on GPU",
+    ModelFit.tight: "fits but tight — reduce context if slow",
+    ModelFit.spills: "exceeds VRAM — partial CPU offload, expect slowdown",
+}
+
+
+def assess_fit(model: str, vram_gb: float) -> ModelFit:
+    """Assess how *model* fits in *vram_gb* of VRAM (REQ-445).
+
+    Unknown models are treated optimistically as ``fits`` so a missing
+    footprint entry never blocks a recommendation.
+    """
+    footprint = _MODEL_FOOTPRINT_GB.get(model)
+    if footprint is None:
+        return ModelFit.fits
+    if footprint + _FIT_HEADROOM_GB <= vram_gb:
+        return ModelFit.fits
+    if footprint <= vram_gb:
+        return ModelFit.tight
+    return ModelFit.spills
+
+
+@dataclass
+class RecommendedModel:
+    """A single VRAM-aware model recommendation for one usage slot (REQ-445)."""
+
+    slot: str
+    """Usage slot: ``default`` | ``fast`` | ``harder`` | ``general``."""
+
+    role: ModelRole
+    """Router role this slot maps to (coding/general/reasoning)."""
+
+    model: str
+    """Ollama model tag."""
+
+    footprint_gb: float
+    """Approximate on-GPU footprint in GB."""
+
+    fit: ModelFit
+    """Fit against the detected VRAM."""
+
+    summary: str
+    """What this slot is for."""
+
+    @property
+    def pull_cmd(self) -> str:
+        return f"ollama pull {self.model}"
+
+    @property
+    def fit_note(self) -> str:
+        return _FIT_NOTE[self.fit]
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "slot": self.slot,
+            "role": self.role.value,
+            "model": self.model,
+            "footprint_gb": self.footprint_gb,
+            "fit": self.fit.value,
+            "fit_note": self.fit_note,
+            "summary": self.summary,
+            "pull_cmd": self.pull_cmd,
+        }
+
+
+@dataclass
+class RecommendedLineup:
+    """A complete VRAM-aware lineup recommendation (REQ-445)."""
+
+    hardware: str
+    vram_gb: float
+    models: list[RecommendedModel]
+
+    def role_config(self) -> dict[str, str]:
+        """Return the role→tag mapping for ``.specsmith/local-models.yml``.
+
+        Maps the router's three roles to lineup slots:
+        ``coding`` → default, ``general`` → general, ``reasoning`` → harder.
+        """
+        by_role: dict[str, str] = {}
+        for rec in self.models:
+            # First write wins per role (slots are emitted in priority order).
+            by_role.setdefault(rec.role.value, rec.model)
+        return by_role
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "hardware": self.hardware,
+            "vram_gb": self.vram_gb,
+            "models": [m.as_dict() for m in self.models],
+        }
+
+
+def _tiered_tag(vram_gb: float, *, tag_32b: str, tag_14b: str, tag_7b: str) -> str:
+    """Select a dense-model tag for *vram_gb* using the NVIDIA VRAM tiers."""
+    if vram_gb >= _TIER_32B_GB:
+        return tag_32b
+    if vram_gb >= _TIER_14B_GB:
+        return tag_14b
+    return tag_7b
+
+
+def recommend_models(vram_gb: float, hardware: str = "") -> RecommendedLineup | None:
+    """Recommend a full role lineup for *vram_gb* of VRAM (REQ-445).
+
+    Returns ``None`` below the minimum tier (``< _TIER_7B_GB``), where local
+    inference would be unusably slow. The lineup always follows the supplied
+    VRAM: the default/general slots scale with the VRAM tier (7b/14b/32b) while
+    the ``fast`` and ``harder`` slots are fixed picks whose fit is reported
+    relative to *vram_gb* so the caller can warn about CPU spillover.
+    """
+    if vram_gb < _TIER_7B_GB:
+        return None
+
+    default_tag = _tiered_tag(vram_gb, tag_32b=_MODEL_32B, tag_14b=_MODEL_14B, tag_7b=_MODEL_7B)
+    general_tag = _tiered_tag(vram_gb, tag_32b=_GEN_32B, tag_14b=_GEN_14B, tag_7b=_GEN_7B)
+
+    specs: list[tuple[str, ModelRole, str, str]] = [
+        ("default", ModelRole.coding, default_tag, "Default daily driver — balanced coding model."),
+        (
+            "fast",
+            ModelRole.coding,
+            _MODEL_7B,
+            "Fast scratch model — quick edits, big context headroom.",
+        ),
+        (
+            "harder",
+            ModelRole.reasoning,
+            _DEEPSEEK_CODER_V2,
+            "Harder C/Python pass — heavier reasoning-capable coder.",
+        ),
+        ("general", ModelRole.general, general_tag, "General chat / project management."),
+    ]
+
+    models = [
+        RecommendedModel(
+            slot=slot,
+            role=role,
+            model=tag,
+            footprint_gb=_MODEL_FOOTPRINT_GB.get(tag, 0.0),
+            fit=assess_fit(tag, vram_gb),
+            summary=summary,
+        )
+        for slot, role, tag, summary in specs
+    ]
+    return RecommendedLineup(hardware=hardware or "unknown", vram_gb=vram_gb, models=models)
+
+
+def recommend_for_hardware() -> RecommendedLineup | None:
+    """Detect the host GPU and recommend a VRAM-aware lineup (REQ-445).
+
+    Mirrors the detection order of :func:`detect_local_models` (Apple Silicon
+    first, then NVIDIA) and applies the same VRAM tiering. Returns ``None`` on
+    CPU-only machines or when the detected VRAM is below the minimum tier.
+    """
+    as_gb = _detect_apple_silicon_gb()
+    if as_gb is not None:
+        return recommend_models(as_gb, hardware=f"apple-silicon-{int(as_gb)}gb")
+    nv_gb = _detect_nvidia_vram_gb()
+    if nv_gb is not None:
+        return recommend_models(nv_gb, hardware=f"nvidia-{int(nv_gb)}gb")
+    return None
+
+
 def ensure_local_model(model_tag: str) -> bool:
     """Pull *model_tag* via Ollama if it is not already present.
 
@@ -426,10 +632,16 @@ def ensure_local_model(model_tag: str) -> bool:
 
 __all__ = [
     "LocalModelInfo",
+    "ModelFit",
     "ModelRole",
+    "RecommendedLineup",
+    "RecommendedModel",
+    "assess_fit",
     "detect_local_model",
     "detect_local_models",
     "ensure_local_model",
     "load_local_models_config",
+    "recommend_for_hardware",
+    "recommend_models",
     "save_local_models_config",
 ]

{specsmith-0.19.2.dev738 → specsmith-0.19.2.dev739}/src/specsmith/mcp_server.py

@@ -122,6 +122,47 @@ def unregister_project(path: str = ".") -> bool:
     return True
 
 
+def build_warp_mcp_config() -> dict[str, Any]:
+    """Build the Warp MCP server config snippet for the governance server.
+
+    Shared by ``specsmith mcp install-warp`` and the ``warp`` integration
+    adapter (REQ-444) so both emit an identical, registry-aware config.
+
+    Executable detection (in priority order):
+      1. ``specsmith`` / ``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).
+
+    The env vars keep the server starting cleanly when Warp launches it directly:
+    ``SPECSMITH_ALLOW_NON_PIPX`` prevents the pipx-enforcement gate from exiting
+    before the MCP handshake; ``SPECSMITH_NO_AUTO_UPDATE`` / ``SPECSMITH_PYPI_CHECKED``
+    suppress startup network calls so the server responds immediately.
+    """
+    import shutil
+
+    server_env = {
+        "SPECSMITH_ALLOW_NON_PIPX": "1",
+        "SPECSMITH_NO_AUTO_UPDATE": "1",
+        "SPECSMITH_PYPI_CHECKED": "1",
+    }
+    specsmith_exe = shutil.which("specsmith") or shutil.which("specsmith.exe")
+    if specsmith_exe:
+        cmd = specsmith_exe
+        args: list[str] = ["mcp", "serve"]
+    else:
+        cmd = sys.executable
+        args = ["-m", "specsmith", "mcp", "serve"]
+    return {
+        "specsmith-governance": {
+            "command": cmd,
+            "args": args,
+            "env": server_env,
+        }
+    }
+
+
 _TOOLS: list[dict[str, Any]] = [
     {
         "name": "governance_project_list",

{specsmith-0.19.2.dev738 → specsmith-0.19.2.dev739/src/specsmith.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.19.2.dev738
+Version: 0.19.2.dev739
 Summary: AEE governance toolkit for AI-assisted development — session preflight gates, multi-agent dispatch, requirements↔test traceability, ESDB persistence, MCP server, and skills for Warp, Cursor, Claude Code, Copilot, Windsurf, and Aider.
 Author: Layer1Labs Silicon, Inc.
 License-Expression: MIT