specsmith 0.10.1.dev250__tar.gz → 0.10.1.dev262__tar.gz

{specsmith-0.10.1.dev250/src/specsmith.egg-info → specsmith-0.10.1.dev262}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.10.1.dev250
+Version: 0.10.1.dev262
 Summary: Applied Epistemic Engineering toolkit — AEE agent sessions, execution profiles, FPGA/HDL governance, tool installer, 50+ CLI commands.
 Author: BitConcepts
 License-Expression: MIT
@@ -38,6 +38,8 @@ Requires-Dist: ruff>=0.4; extra == "dev"
 Requires-Dist: mypy>=1.10; extra == "dev"
 Requires-Dist: pre-commit>=3.0; extra == "dev"
 Requires-Dist: types-pyyaml>=6.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-textual-snapshot>=1.0; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: mkdocs>=1.6; extra == "docs"
 Requires-Dist: mkdocs-material>=9.5; extra == "docs"
@@ -51,6 +53,10 @@ Provides-Extra: mistral
 Requires-Dist: openai>=1.0; extra == "mistral"
 Provides-Extra: gui
 Requires-Dist: PySide6>=6.6; extra == "gui"
+Provides-Extra: tui
+Requires-Dist: textual>=3.0; extra == "tui"
+Provides-Extra: webui
+Requires-Dist: nicegui>=3.0; extra == "webui"
 Provides-Extra: ag2
 Requires-Dist: ag2[ollama]; extra == "ag2"
 Provides-Extra: history-semantic

{specsmith-0.10.1.dev250 → specsmith-0.10.1.dev262}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsmith"
-version = "0.10.1.dev250"
+version = "0.10.1.dev262"
 description = "Applied Epistemic Engineering toolkit — AEE agent sessions, execution profiles, FPGA/HDL governance, tool installer, 50+ CLI commands."
 readme = "README.md"
 license = "MIT"
@@ -51,6 +51,8 @@ dev = [
     "mypy>=1.10",
     "pre-commit>=3.0",
     "types-pyyaml>=6.0",
+    "pytest-asyncio>=0.23",
+    "pytest-textual-snapshot>=1.0",
 ]
 docs = [
     "mkdocs>=1.6",
@@ -65,6 +67,8 @@ openai = ["openai>=1.0"]
 gemini = ["google-genai>=1.0"]
 mistral = ["openai>=1.0"]  # Mistral uses the openai SDK pointed at api.mistral.ai
 gui = ["PySide6>=6.6"]
+tui = ["textual>=3.0"]
+webui = ["nicegui>=3.0"]
 # AG2 agent shell (Planner/Builder/Verifier over Ollama)
 ag2 = ["ag2[ollama]"]
 # Optional semantic backend for `specsmith history search --semantic` (REQ-135).
@@ -182,8 +186,15 @@ module = [
     "specsmith.serve",
     "specsmith.toolrules",
     "specsmith.tool_installer",
+    "specsmith.commands.*",
+    "specsmith.eval.*",
+    "specsmith.feature_flags",
+    "specsmith.instinct",
+    "specsmith.tui.*",
+    "specsmith.webui.*",
 ]
 ignore_errors = true
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+asyncio_mode = "auto"

{specsmith-0.10.1.dev250 → specsmith-0.10.1.dev262}/src/specsmith/agent/chat_runner.py

@@ -17,6 +17,7 @@ green on machines that have no LLM configured at all.
 
 from __future__ import annotations
 
+import inspect as _inspect
 import json
 import os
 from dataclasses import dataclass, field
@@ -324,7 +325,7 @@ def _run_openai(
     # ``stream_options.include_usage`` makes the final SSE chunk carry a
     # populated ``usage`` block (otherwise streaming responses emit it as
     # ``None``). Older SDK versions silently ignore unknown kwargs.
-    stream = client.chat.completions.create(
+    stream = client.chat.completions.create(  # type: ignore[call-overload,unused-ignore]
         model=os.environ.get("OPENAI_MODEL", "gpt-4o-mini"),
         messages=messages,
         stream=True,
@@ -344,6 +345,63 @@ def _run_openai(
     return ("".join(pieces) if pieces else None), usage
 
 
+# ---------------------------------------------------------------------------
+# OpenAI function-calling tool definitions (generated from AVAILABLE_TOOLS)
+# ---------------------------------------------------------------------------
+
+_TOOL_DEFS: list[dict[str, Any]] | None = None
+_TOOL_MAP: dict[str, Any] | None = None
+
+
+def _openai_tool_defs() -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    """Build OpenAI function-calling tool definitions from AVAILABLE_TOOLS.
+
+    Returns ``(definitions, name_to_func_map)``.
+    """
+    global _TOOL_DEFS, _TOOL_MAP  # noqa: PLW0603
+    if _TOOL_DEFS is not None and _TOOL_MAP is not None:
+        return _TOOL_DEFS, _TOOL_MAP
+
+    from specsmith.agent.tools import AVAILABLE_TOOLS
+
+    TYPE_MAP = {str: "string", int: "integer", float: "number", bool: "boolean"}
+    defs: list[dict[str, Any]] = []
+    fmap: dict[str, Any] = {}
+    for fn in AVAILABLE_TOOLS:
+        sig = _inspect.signature(fn)
+        props: dict[str, Any] = {}
+        required: list[str] = []
+        for pname, param in sig.parameters.items():
+            ann = param.annotation
+            # Unwrap Optional (str | None)
+            origin = getattr(ann, "__origin__", None)
+            if origin is type(str | None):  # types.UnionType
+                args = [a for a in ann.__args__ if a is not type(None)]
+                ann = args[0] if args else str
+            ptype = TYPE_MAP.get(ann, "string")
+            props[pname] = {"type": ptype}
+            if param.default is _inspect.Parameter.empty:
+                required.append(pname)
+        defs.append(
+            {
+                "type": "function",
+                "function": {
+                    "name": fn.__name__,
+                    "description": (fn.__doc__ or "").strip().split("\n")[0],
+                    "parameters": {
+                        "type": "object",
+                        "properties": props,
+                        "required": required,
+                    },
+                },
+            }
+        )
+        fmap[fn.__name__] = fn
+    _TOOL_DEFS = defs
+    _TOOL_MAP = fmap
+    return defs, fmap
+
+
 def _run_openai_compat(
     messages: list[dict[str, str]],
     emitter: EventEmitter,
@@ -353,18 +411,16 @@ def _run_openai_compat(
 ) -> tuple[str | None, _UsageDelta]:
     """Stream from a user-registered OpenAI-v1-compatible endpoint (REQ-142).
 
-    Uses raw stdlib HTTP so the openai SDK is not a hard dependency for
-    BYOE. Sends a streaming ``/chat/completions`` request, decodes the
-    Server-Sent-Events ``data:`` lines, and forwards each ``content``
-    delta as a ``token`` event on ``block_id``.
+    Supports tool calling: sends tool definitions in the request, detects
+    tool_calls in the streaming response, executes the tools locally, and
+    loops back with results until the model produces a final text answer.
+    Capped at 20 iterations to prevent infinite loops.
     """
     usage = _UsageDelta()
     base_url = endpoint.base_url.rstrip("/")
     url = f"{base_url}/chat/completions"
     model = endpoint.default_model or os.environ.get("SPECSMITH_OPENAI_COMPAT_MODEL", "")
     if not model:
-        # The endpoint did not pin a default model and the env override is
-        # absent. We cannot fabricate one; fall back to the auto-detect chain.
         return None, usage
 
     headers: dict[str, str] = {
@@ -373,23 +429,11 @@ def _run_openai_compat(
     }
     try:
         token = endpoint.resolve_token()
-    except Exception:  # noqa: BLE001 - fall back to auto-detect chain
+    except Exception:  # noqa: BLE001
         return None, usage
     if token:
         headers["Authorization"] = f"Bearer {token}"
 
-    body = json.dumps(
-        {
-            "model": model,
-            "messages": messages,
-            "stream": True,
-            # Many vLLM/llama.cpp builds honour OpenAI's stream_options;
-            # the request is harmless if they don't.
-            "stream_options": {"include_usage": True},
-        }
-    ).encode("utf-8")
-    req = Request(url, data=body, headers=headers, method="POST")  # noqa: S310 - user-supplied
-
     ctx = None
     if not endpoint.verify_tls and url.startswith("https://"):
         import ssl
@@ -398,37 +442,151 @@ def _run_openai_compat(
         ctx.check_hostname = False
         ctx.verify_mode = ssl.CERT_NONE
 
-    pieces: list[str] = []
-    try:
-        with urlopen(req, timeout=120, context=ctx) as resp:  # noqa: S310 - user-supplied
-            for raw_line in resp:
-                line = raw_line.decode("utf-8", errors="replace").rstrip("\n\r")
-                if not line.startswith("data:"):
-                    continue
-                payload = line[len("data:") :].strip()
-                if not payload or payload == "[DONE]":
-                    if payload == "[DONE]":
-                        break
-                    continue
+    tool_defs, tool_map = _openai_tool_defs()
+    # Use a mutable copy of messages for the tool-call loop
+    loop_messages: list[dict[str, Any]] = [dict(m) for m in messages]
+    all_text: list[str] = []
+    MAX_TOOL_ITERS = 20
+
+    for _loop in range(MAX_TOOL_ITERS):
+        body = json.dumps(
+            {
+                "model": model,
+                "messages": loop_messages,
+                "stream": True,
+                "stream_options": {"include_usage": True},
+                "tools": tool_defs,
+            }
+        ).encode("utf-8")
+        req = Request(url, data=body, headers=headers, method="POST")  # noqa: S310
+
+        pieces: list[str] = []
+        # Accumulate tool_calls fragments from the stream
+        tc_accum: dict[int, dict[str, str]] = {}  # index → {id, name, arguments}
+        finish_reason = ""
+
+        try:
+            with urlopen(req, timeout=120, context=ctx) as resp:  # noqa: S310
+                for raw_line in resp:
+                    line = raw_line.decode("utf-8", errors="replace").rstrip("\n\r")
+                    if not line.startswith("data:"):
+                        continue
+                    payload = line[len("data:") :].strip()
+                    if not payload or payload == "[DONE]":
+                        if payload == "[DONE]":
+                            break
+                        continue
+                    try:
+                        obj = json.loads(payload)
+                    except ValueError:
+                        continue
+                    choices = obj.get("choices") or []
+                    usage_obj = obj.get("usage")
+                    if usage_obj:
+                        usage.tokens_in += int(usage_obj.get("prompt_tokens") or 0)
+                        usage.tokens_out += int(usage_obj.get("completion_tokens") or 0)
+                    if not choices:
+                        continue
+                    choice = choices[0] or {}
+                    delta = choice.get("delta") or {}
+                    fr = choice.get("finish_reason") or ""
+                    if fr:
+                        finish_reason = fr
+                    # Text content
+                    chunk = str(delta.get("content") or "")
+                    if chunk:
+                        emitter.emit({"type": "llm_chunk", "text": chunk})
+                        pieces.append(chunk)
+                    # Tool call fragments
+                    for tc_delta in delta.get("tool_calls") or []:
+                        idx = tc_delta.get("index", 0)
+                        if idx not in tc_accum:
+                            tc_accum[idx] = {
+                                "id": tc_delta.get("id", f"call_{idx}"),
+                                "name": "",
+                                "arguments": "",
+                            }
+                        fn = tc_delta.get("function") or {}
+                        if fn.get("name"):
+                            tc_accum[idx]["name"] = fn["name"]
+                        if fn.get("arguments"):
+                            tc_accum[idx]["arguments"] += fn["arguments"]
+        except (URLError, TimeoutError, OSError):
+            return None, usage
+
+        text_this_turn = "".join(pieces)
+        if text_this_turn:
+            all_text.append(text_this_turn)
+
+        # If the model didn't call any tools, we're done
+        if finish_reason != "tool_calls" and not tc_accum:
+            break
+
+        # Execute tool calls
+        assistant_msg: dict[str, Any] = {
+            "role": "assistant",
+            "content": text_this_turn or None,
+            "tool_calls": [],
+        }
+        tool_result_msgs: list[dict[str, Any]] = []
+
+        for idx in sorted(tc_accum):
+            tc = tc_accum[idx]
+            name = tc["name"]
+            call_id = tc["id"]
+            try:
+                args = json.loads(tc["arguments"]) if tc["arguments"] else {}
+            except ValueError:
+                args = {}
+
+            assistant_msg["tool_calls"].append(
+                {
+                    "id": call_id,
+                    "type": "function",
+                    "function": {"name": name, "arguments": tc["arguments"]},
+                }
+            )
+
+            # Emit tool_started
+            emitter.emit({"type": "tool_started", "name": name, "args": args})
+
+            # Execute
+            fn = tool_map.get(name)
+            is_error = False
+            if fn:
                 try:
-                    obj = json.loads(payload)
-                except ValueError:
-                    continue
-                choices = obj.get("choices") or []
-                usage_obj = obj.get("usage")
-                if usage_obj:
-                    usage.tokens_in = int(usage_obj.get("prompt_tokens") or 0)
-                    usage.tokens_out = int(usage_obj.get("completion_tokens") or 0)
-                if not choices:
-                    continue
-                delta = (choices[0] or {}).get("delta") or {}
-                chunk = str(delta.get("content") or "")
-                if chunk:
-                    emitter.token(block_id, chunk)
-                    pieces.append(chunk)
-    except (URLError, TimeoutError, OSError):
-        return None, usage
-    return ("".join(pieces) if pieces else None), usage
+                    result_text = fn(**args)
+                except Exception as exc:  # noqa: BLE001
+                    result_text = f"[ERROR] {exc}"
+                    is_error = True
+            else:
+                result_text = f"[Unknown tool: {name}]"
+                is_error = True
+
+            # Emit tool_finished
+            emitter.emit(
+                {
+                    "type": "tool_finished",
+                    "name": name,
+                    "result": str(result_text)[:4000],
+                    "is_error": is_error,
+                    "args": args,
+                }
+            )
+
+            tool_result_msgs.append(
+                {
+                    "role": "tool",
+                    "tool_call_id": call_id,
+                    "content": str(result_text)[:8000],
+                }
+            )
+
+        # Append assistant + tool results and loop for next turn
+        loop_messages.append(assistant_msg)
+        loop_messages.extend(tool_result_msgs)
+
+    return ("".join(all_text) if all_text else None), usage
 
 
 def _run_gemini(

{specsmith-0.10.1.dev250 → specsmith-0.10.1.dev262}/src/specsmith/agent/repl.py

@@ -10,9 +10,13 @@ from specsmith.agent.broker import (
     run_preflight,
 )
 from specsmith.agent.orchestrator import Orchestrator
+from specsmith.commands.registry import available_commands
+from specsmith.commands.registry import dispatch as dispatch_command
 
 NEXUS_BANNER = "Nexus — Local-first Agentic Development Environment (Specsmith-governed)"
 
+_REGISTERED_COMMANDS = set(available_commands())
+
 
 def main():
     print(NEXUS_BANNER)
@@ -27,7 +31,8 @@ def main():
 
     print(
         "Agents ready. Type plain English to use the natural-language broker, "
-        "or use slash commands (/plan, /ask, /fix, /why, /exit). "
+        "or use slash commands (/plan, /ask, /fix, /test, /review, /context, "
+        "/commit, /pr, /undo, /why, /exit). "
         "Toggle governance details with /why."
     )
 
@@ -59,38 +64,11 @@ def main():
             print(f"Governance details: {state}")
             continue
 
-        if command == "/plan":
-            if not args:
-                print("Usage: /plan <task description>")
-                continue
-            orchestrator.run_task(f"[PLAN] Create a step-by-step plan for: {args}")
-
-        elif command == "/ask":
-            if not args:
-                print("Usage: /ask <question>")
-                continue
-            orchestrator.run_task(f"[ASK] Clarify intent and answer the following question: {args}")
-
-        elif command == "/fix":
-            if not args:
-                print("Usage: /fix <issue description or file>")
-                continue
-            orchestrator.run_task(f"[FIX] Modify code to fix the following issue: {args}")
-
-        elif command == "/test":
-            orchestrator.run_task(f"[TEST] Run tests for the project. {args}")
-
-        elif command == "/commit":
-            orchestrator.run_task(f"[COMMIT] Create a git commit for the current changes. {args}")
-
-        elif command == "/pr":
-            orchestrator.run_task(f"[PR] Prepare a pull request for the current branch. {args}")
-
-        elif command == "/undo":
-            orchestrator.run_task(f"[UNDO] Revert the last action or commit. {args}")
-
-        elif command == "/context":
-            orchestrator.run_task(f"[CONTEXT] Show repo knowledge and search context for: {args}")
+        # Dispatch registered slash commands through the registry.
+        if command in _REGISTERED_COMMANDS:
+            cmd_result = dispatch_command(command, args, project_dir, orchestrator)
+            print(cmd_result.output)
+            continue
 
         else:
             # Default mode (REQ-084 + REQ-086): plain English flows through the

{specsmith-0.10.1.dev250 → specsmith-0.10.1.dev262}/src/specsmith/agent/runner.py

@@ -188,6 +188,13 @@ class AgentRunner:
         """
         version = self._package_version()
         if self.json_events:
+            # Report tool count so the VS Code extension can show "(N tools)"
+            try:
+                from specsmith.agent.tools import AVAILABLE_TOOLS as _AT
+
+                _tool_count = len(_AT)
+            except Exception:  # noqa: BLE001
+                _tool_count = 0
             self._emitter.ready(
                 agent="nexus",
                 version=version,
@@ -197,6 +204,7 @@ class AgentRunner:
                 profile_id=self.profile_id or "",
                 capabilities=_capabilities(),
                 endpoint_id=self.endpoint_id or "",
+                tools=_tool_count,
             )
         else:
             print(