specsmith 0.5.0.dev226__tar.gz → 0.5.0.dev228__tar.gz

{specsmith-0.5.0.dev226/src/specsmith.egg-info → specsmith-0.5.0.dev228}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.5.0.dev226
+Version: 0.5.0.dev228
 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.5.0.dev226 → specsmith-0.5.0.dev228}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsmith"
-version = "0.5.0.dev226"
+version = "0.5.0.dev228"
 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.5.0.dev228/src/specsmith/agent/chat_runner.py

@@ -0,0 +1,337 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 BitConcepts, LLC. All rights reserved.
+"""Real LLM-backed runner for `specsmith chat` (REQ-108, REQ-112-118).
+
+This module replaces the deterministic stub that previously lived inside
+`chat_cmd`. It selects the first available provider (Ollama → Anthropic →
+OpenAI → Gemini) and streams the model's response as `token` events
+through the supplied :class:`EventEmitter`. Output is then parsed for
+``Files changed:`` and ``Test results:`` sections so the verifier can
+emit a real verdict.
+
+The runner is deliberately defensive: any provider error (missing SDK,
+unreachable endpoint, network failure) returns ``None`` so the caller
+can fall back to the deterministic stub. This keeps the test suite
+green on machines that have no LLM configured at all.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+from urllib.error import URLError
+from urllib.request import Request, urlopen
+
+from specsmith.agent.events import EventEmitter
+from specsmith.agent.verifier import (
+    VerifierVerdict,
+    report_from_chat_sections,
+    score,
+)
+
+DEFAULT_OLLAMA_HOST = "http://127.0.0.1:11434"
+DEFAULT_OLLAMA_MODEL = os.environ.get("SPECSMITH_OLLAMA_MODEL", "qwen2.5:7b")
+SYSTEM_PROMPT = (
+    "You are Nexus, the local-first agentic developer assistant inside "
+    "Specsmith. Always end your response with the canonical contract:\n"
+    "Plan:\n"
+    "Files changed:\n"
+    "Test results:\n"
+    "Next action:\n"
+)
+
+
+@dataclass
+class ChatRunResult:
+    """Return value of :func:`run_chat`."""
+
+    provider: str
+    summary: str
+    files_changed: list[str] = field(default_factory=list)
+    verdict: VerifierVerdict | None = None
+    raw_text: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "provider": self.provider,
+            "summary": self.summary,
+            "files_changed": list(self.files_changed),
+            "confidence": self.verdict.confidence if self.verdict else 0.0,
+            "equilibrium": self.verdict.equilibrium if self.verdict else False,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Public entry point
+# ---------------------------------------------------------------------------
+
+
+def run_chat(
+    utterance: str,
+    *,
+    project_dir: Path,
+    profile: str,
+    session_id: str,
+    emitter: EventEmitter,
+    msg_block: str,
+    history: list[dict[str, Any]] | None = None,
+    confidence_target: float = 0.7,
+    rules_prefix: str = "",
+) -> ChatRunResult | None:
+    """Drive a real LLM turn. Return ``None`` if no provider is reachable."""
+    history = history or []
+    messages = _build_messages(utterance, history, rules_prefix)
+
+    # Order matters: Ollama first because it's local-first and free.
+    for provider in (_run_ollama, _run_anthropic, _run_openai, _run_gemini):
+        try:
+            full_text = provider(messages, emitter, msg_block)
+        except Exception:  # noqa: BLE001 - any failure → next provider
+            continue
+        if full_text is None:
+            continue
+        return _finalize(full_text, provider.__name__, project_dir, confidence_target)
+    return None
+
+
+def _finalize(
+    full_text: str,
+    provider_fn_name: str,
+    project_dir: Path,
+    confidence_target: float,
+) -> ChatRunResult:
+    sections = _parse_output_contract(full_text)
+    files_changed = _split_files_list(sections.get("files_changed", ""))
+    report = report_from_chat_sections(sections, files_changed=files_changed)
+    verdict = score(report, confidence_target=confidence_target)
+    summary = (sections.get("plan") or full_text.strip()[:200]).strip() or verdict.summary
+    return ChatRunResult(
+        provider=provider_fn_name.removeprefix("_run_"),
+        summary=summary,
+        files_changed=files_changed,
+        verdict=verdict,
+        raw_text=full_text,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Provider drivers — each returns the full assembled text or None
+# ---------------------------------------------------------------------------
+
+
+def _run_ollama(
+    messages: list[dict[str, str]],
+    emitter: EventEmitter,
+    block_id: str,
+) -> str | None:
+    """Stream from a local Ollama daemon using only stdlib."""
+    host = os.environ.get("OLLAMA_HOST", DEFAULT_OLLAMA_HOST).rstrip("/")
+    model = os.environ.get("SPECSMITH_OLLAMA_MODEL", DEFAULT_OLLAMA_MODEL)
+
+    if not _ollama_alive(host):
+        return None
+
+    payload = json.dumps({"model": model, "messages": messages, "stream": True}).encode("utf-8")
+    req = Request(  # noqa: S310 - URL is a hardcoded localhost default
+        f"{host}/api/chat",
+        data=payload,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+
+    pieces: list[str] = []
+    with urlopen(req, timeout=120) as resp:  # noqa: S310
+        for raw_line in resp:
+            line = raw_line.decode("utf-8", errors="replace").strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except ValueError:
+                continue
+            chunk = ((obj.get("message") or {}).get("content")) or ""
+            if chunk:
+                emitter.token(block_id, chunk)
+                pieces.append(chunk)
+            if obj.get("done"):
+                break
+    return "".join(pieces) if pieces else None
+
+
+def _ollama_alive(host: str) -> bool:
+    try:
+        with urlopen(f"{host}/api/tags", timeout=2):  # noqa: S310
+            return True
+    except (URLError, TimeoutError, OSError):
+        return False
+
+
+def _run_anthropic(
+    messages: list[dict[str, str]],
+    emitter: EventEmitter,
+    block_id: str,
+) -> str | None:
+    """Use the anthropic SDK if installed and a key is configured."""
+    if not os.environ.get("ANTHROPIC_API_KEY"):
+        return None
+    try:
+        import anthropic
+    except ImportError:
+        return None
+
+    system = "\n".join(m["content"] for m in messages if m["role"] == "system")
+    user_msgs = [m for m in messages if m["role"] != "system"]
+    client = anthropic.Anthropic()
+    pieces: list[str] = []
+    with client.messages.stream(
+        model=os.environ.get("ANTHROPIC_MODEL", "claude-haiku-4-5"),
+        max_tokens=2048,
+        system=system,
+        messages=[{"role": m["role"], "content": m["content"]} for m in user_msgs],
+    ) as stream:
+        for event in stream:
+            text = getattr(getattr(event, "delta", None), "text", None)
+            if text:
+                emitter.token(block_id, text)
+                pieces.append(text)
+    return "".join(pieces) if pieces else None
+
+
+def _run_openai(
+    messages: list[dict[str, str]],
+    emitter: EventEmitter,
+    block_id: str,
+) -> str | None:
+    """Use the openai SDK if installed and a key is configured."""
+    if not os.environ.get("OPENAI_API_KEY"):
+        return None
+    try:
+        from openai import OpenAI
+    except ImportError:
+        return None
+
+    client = OpenAI()
+    stream = client.chat.completions.create(
+        model=os.environ.get("OPENAI_MODEL", "gpt-4o-mini"),
+        messages=messages,
+        stream=True,
+    )
+    pieces: list[str] = []
+    for chunk in stream:
+        text = (chunk.choices[0].delta.content or "") if chunk.choices else ""
+        if text:
+            emitter.token(block_id, text)
+            pieces.append(text)
+    return "".join(pieces) if pieces else None
+
+
+def _run_gemini(
+    messages: list[dict[str, str]],
+    emitter: EventEmitter,
+    block_id: str,
+) -> str | None:
+    """Use google-genai SDK if installed and a key is configured."""
+    if not os.environ.get("GOOGLE_API_KEY"):
+        return None
+    try:
+        from google import genai
+    except ImportError:
+        return None
+
+    client = genai.Client()
+    prompt = "\n".join(f"{m['role']}: {m['content']}" for m in messages)
+    pieces: list[str] = []
+    for chunk in client.models.generate_content_stream(
+        model=os.environ.get("GEMINI_MODEL", "gemini-2.5-flash"),
+        contents=prompt,
+    ):
+        text = getattr(chunk, "text", "") or ""
+        if text:
+            emitter.token(block_id, text)
+            pieces.append(text)
+    return "".join(pieces) if pieces else None
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _build_messages(
+    utterance: str,
+    history: list[dict[str, Any]],
+    rules_prefix: str,
+) -> list[dict[str, str]]:
+    system = SYSTEM_PROMPT
+    if rules_prefix:
+        system = f"{system}\n\nProject rules:\n{rules_prefix}"
+    msgs: list[dict[str, str]] = [{"role": "system", "content": system}]
+    for turn in history[-10:]:
+        text = str(turn.get("utterance") or turn.get("text") or "").strip()
+        if text:
+            msgs.append({"role": "user", "content": text})
+    msgs.append({"role": "user", "content": utterance})
+    return msgs
+
+
+def _parse_output_contract(text: str) -> dict[str, str]:
+    """Extract canonical Nexus output sections from free-form text.
+
+    The contract is `Plan:`, `Commands to run:`, `Files changed:`,
+    `Diff:`, `Test results:`, `Next action:`. Sections that don't
+    appear are returned as empty strings.
+    """
+    keys = [
+        ("plan", "Plan:"),
+        ("commands_to_run", "Commands to run:"),
+        ("files_changed", "Files changed:"),
+        ("diff", "Diff:"),
+        ("test_results", "Test results:"),
+        ("next_action", "Next action:"),
+    ]
+    out: dict[str, str] = {key: "" for key, _ in keys}
+    lower = text.lower()
+    bounds: list[tuple[str, int]] = []
+    for key, header in keys:
+        idx = lower.find(header.lower())
+        if idx >= 0:
+            bounds.append((key, idx + len(header)))
+    bounds.sort(key=lambda b: b[1])
+    for i, (key, start) in enumerate(bounds):
+        if i + 1 < len(bounds):
+            next_key, next_pos = bounds[i + 1]
+            end = next_pos - len(_section_header(next_key))
+        else:
+            end = len(text)
+        out[key] = text[start:end].strip()
+    return out
+
+
+def _section_header(key: str) -> str:
+    return {
+        "plan": "Plan:",
+        "commands_to_run": "Commands to run:",
+        "files_changed": "Files changed:",
+        "diff": "Diff:",
+        "test_results": "Test results:",
+        "next_action": "Next action:",
+    }[key]
+
+
+def _split_files_list(text: str) -> list[str]:
+    items: list[str] = []
+    for raw in text.splitlines():
+        line = raw.strip()
+        if not line:
+            continue
+        if line.startswith(("-", "*", "+")):
+            line = line[1:].strip()
+        if line:
+            items.append(line)
+    return items
+
+
+__all__ = ["ChatRunResult", "run_chat"]

{specsmith-0.5.0.dev226 → specsmith-0.5.0.dev228}/src/specsmith/cli.py

@@ -5258,6 +5258,7 @@ def chat_cmd(
     events instead of executing tool calls (REQ-115).
     """
     import json as _json
+    import os
     import uuid as _uuid
 
     from specsmith.agent.events import EventEmitter
@@ -5363,10 +5364,38 @@ def chat_cmd(
     emitter.tool_call(msg_block, "execute_with_governance", {"utterance": utterance})
     emitter.plan_step(plan_block, "s2", "complete")
 
-    # Verifier sketch (deterministic, no LLM needed for this stub):
-    summary = (
-        f"Preflight intent={real_intent.value}, matched_reqs={len(scope.matched_requirements)}."
-    )
+    # Real LLM turn — try Ollama / Anthropic / OpenAI / Gemini via
+    # specsmith.agent.chat_runner. Any failure (no provider, network
+    # error, missing SDK) returns ``None`` so we fall back to the
+    # deterministic stub below. This keeps the test suite green on
+    # machines without an LLM configured at all.
+    real_result = None
+    if os.environ.get("SPECSMITH_DISABLE_REAL_CHAT", "").lower() not in ("1", "true", "yes"):
+        try:
+            from specsmith.agent.chat_runner import run_chat as _run_chat
+
+            real_result = _run_chat(
+                utterance,
+                project_dir=root,
+                profile=profile,
+                session_id=sid,
+                emitter=emitter,
+                msg_block=msg_block,
+                history=history,
+                rules_prefix=rules_prefix,
+            )
+        except Exception:  # noqa: BLE001 - real chat is best-effort
+            real_result = None
+
+    if real_result is not None:
+        verdict = real_result.verdict
+        summary = real_result.summary or (verdict.summary if verdict else "")
+    else:
+        # Verifier sketch (deterministic, no LLM needed for this stub):
+        verdict = None
+        summary = (
+            f"Preflight intent={real_intent.value}, matched_reqs={len(scope.matched_requirements)}."
+        )
     if reviewer_comment:
         summary += f" reviewer_comment={reviewer_comment!r}"
     emitter.plan_step(plan_block, "s3", "complete", summary=summary)
@@ -5383,13 +5412,13 @@ def chat_cmd(
         for req in scope.matched_requirements[:3]:
             diff_block = emitter.diff(
                 path=f"docs/{req.req_id}.md",
-                diff=f"--- {req.req_id} (review)\n+++ {req.req_id} (proposed)\n",
+                body=f"--- {req.req_id} (review)\n+++ {req.req_id} (proposed)\n",
             )
             decision = _read_stdin_decision("diff_decision", decision_timeout)
-            verdict = (decision or {}).get("decision", "timeout")
+            decision_status = (decision or {}).get("decision", "timeout")
             comment = (decision or {}).get("comment", "")
-            emitter.block_complete(diff_block, status=verdict)
-            if verdict != "accept" and comment:
+            emitter.block_complete(diff_block, status=decision_status)
+            if decision_status != "accept" and comment:
                 extra_comment = comment
                 break
 
@@ -5397,9 +5426,12 @@ def chat_cmd(
     if extra_comment:
         final_summary += f" reviewer_comment={extra_comment!r}"
 
+    final_confidence = (
+        verdict.confidence if real_result is not None and verdict is not None else 0.7
+    )
     emitter.task_complete(
-        success=True,
-        confidence=0.7,
+        success=real_result is None or (verdict is not None and verdict.equilibrium),
+        confidence=final_confidence,
         summary=final_summary,
         profile=profile,
         session_id=sid,

{specsmith-0.5.0.dev226 → specsmith-0.5.0.dev228/src/specsmith.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.5.0.dev226
+Version: 0.5.0.dev228
 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.5.0.dev226 → specsmith-0.5.0.dev228}/src/specsmith.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ src/specsmith.egg-info/requires.txt
 src/specsmith.egg-info/top_level.txt
 src/specsmith/agent/__init__.py
 src/specsmith/agent/broker.py
+src/specsmith/agent/chat_runner.py
 src/specsmith/agent/cleanup.py
 src/specsmith/agent/events.py
 src/specsmith/agent/indexer.py
@@ -152,6 +153,7 @@ src/specsmith/vcs/github.py
 src/specsmith/vcs/gitlab.py
 tests/test_CMD_001.py
 tests/test_auditor.py
+tests/test_chat_diff_decision.py
 tests/test_chat_stdin_protocol.py
 tests/test_cli.py
 tests/test_cli_workflows_history_drive.py

specsmith-0.5.0.dev228/tests/test_chat_diff_decision.py

@@ -0,0 +1,158 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 BitConcepts, LLC. All rights reserved.
+"""Tests for `specsmith chat --interactive` inline diff-decision flow.
+
+The diff-decision protocol is the second half of the interactive contract
+(``test_chat_stdin_protocol`` covers tool_decision). When the broker
+matches a requirement, the chat command emits one diff block per matched
+REQ and consumes a ``diff_decision`` JSON line from stdin per block. A
+non-accept verdict with a ``comment`` field becomes the next-retry
+reviewer comment (REQ-116).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from specsmith.cli import main
+
+REQUIREMENTS_MD = """# Requirements
+
+## 1. Hello world greeter
+
+- **ID:** REQ-001
+- **Description:** Implement a hello world greeter so the agent can introduce itself.
+"""
+
+
+def _seed_project(tmp_path: Path) -> None:
+    """Write the minimum REQUIREMENTS.md so the broker has a scope match."""
+    (tmp_path / "REQUIREMENTS.md").write_text(REQUIREMENTS_MD, encoding="utf-8")
+
+
+def _events(output: str) -> list[dict]:
+    return [
+        json.loads(line)
+        for line in output.splitlines()
+        if line.startswith("{") and '"type"' in line
+    ]
+
+
+def test_chat_interactive_diff_decision_emits_diff_block(tmp_path: Path) -> None:
+    """A matched REQ should produce a diff block_start whose status accepts."""
+    _seed_project(tmp_path)
+    runner = CliRunner()
+    decisions = (
+        json.dumps({"type": "tool_decision", "decision": "approve"})
+        + "\n"
+        + json.dumps({"type": "diff_decision", "decision": "accept"})
+        + "\n"
+    )
+    res = runner.invoke(
+        main,
+        [
+            "chat",
+            "add hello world greeter",
+            "--project-dir",
+            str(tmp_path),
+            "--profile",
+            "safe",
+            "--interactive",
+            "--decision-timeout",
+            "5",
+        ],
+        input=decisions,
+        env={"SPECSMITH_DISABLE_REAL_CHAT": "1"},
+    )
+    assert res.exit_code == 0, res.output
+    events = _events(res.output)
+    diff_blocks = [e for e in events if e.get("type") == "block_start" and e.get("kind") == "diff"]
+    assert diff_blocks, "expected at least one diff block_start"
+    diff_completes = [
+        e
+        for e in events
+        if e.get("type") == "block_complete" and e.get("block_id") == diff_blocks[0]["block_id"]
+    ]
+    assert diff_completes, "diff block should have been completed"
+    assert diff_completes[-1]["payload"].get("status") == "accept"
+
+
+def test_chat_interactive_diff_decision_reject_threads_comment(tmp_path: Path) -> None:
+    """A non-accept verdict with a comment should fold into the final summary."""
+    _seed_project(tmp_path)
+    runner = CliRunner()
+    decisions = (
+        json.dumps({"type": "tool_decision", "decision": "approve"})
+        + "\n"
+        + json.dumps(
+            {
+                "type": "diff_decision",
+                "decision": "reject",
+                "comment": "use uppercase greeting",
+            }
+        )
+        + "\n"
+    )
+    res = runner.invoke(
+        main,
+        [
+            "chat",
+            "add hello world greeter",
+            "--project-dir",
+            str(tmp_path),
+            "--profile",
+            "safe",
+            "--interactive",
+            "--decision-timeout",
+            "5",
+        ],
+        input=decisions,
+        env={"SPECSMITH_DISABLE_REAL_CHAT": "1"},
+    )
+    assert res.exit_code == 0, res.output
+    events = _events(res.output)
+    diff_completes = [
+        e
+        for e in events
+        if e.get("type") == "block_complete" and e.get("payload", {}).get("status") == "reject"
+    ]
+    assert diff_completes, "expected the diff block to be completed with reject status"
+    completes = [e for e in events if e.get("type") == "task_complete"]
+    assert completes
+    assert "use uppercase greeting" in completes[-1].get("summary", "")
+
+
+def test_chat_interactive_diff_decision_timeout_uses_timeout_status(
+    tmp_path: Path,
+) -> None:
+    """No diff_decision on stdin should mark the diff block as timeout."""
+    _seed_project(tmp_path)
+    runner = CliRunner()
+    decisions = json.dumps({"type": "tool_decision", "decision": "approve"}) + "\n"
+    res = runner.invoke(
+        main,
+        [
+            "chat",
+            "add hello world greeter",
+            "--project-dir",
+            str(tmp_path),
+            "--profile",
+            "safe",
+            "--interactive",
+            "--decision-timeout",
+            "1",
+        ],
+        input=decisions,
+        env={"SPECSMITH_DISABLE_REAL_CHAT": "1"},
+    )
+    assert res.exit_code == 0, res.output
+    events = _events(res.output)
+    diff_completes = [
+        e
+        for e in events
+        if e.get("type") == "block_complete" and e.get("payload", {}).get("status") == "timeout"
+    ]
+    assert diff_completes, "expected at least one diff block to time out"