specsmith 0.10.1.dev292__tar.gz → 0.10.1.dev294__tar.gz

{specsmith-0.10.1.dev292 → specsmith-0.10.1.dev294}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.10.1.dev292
+Version: 0.10.1.dev294
 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.10.1.dev292 → specsmith-0.10.1.dev294}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsmith"
-version = "0.10.1.dev292"
+version = "0.10.1.dev294"
 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.10.1.dev294/src/specsmith/esdb/__init__.py

@@ -0,0 +1,20 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 Layer1Labs / BitConcepts, LLC.
+"""ChronoMemory ESDB Python bridge.
+
+Provides a pure-Python adapter for the Rust ESDB engine.
+Until PyO3 bindings are compiled, this module exposes the ESDB
+data model as Python dataclasses that mirror the Rust types.
+"""
+
+from __future__ import annotations
+
+__all__ = ["EsdbBridge", "is_esdb_available"]
+
+
+def is_esdb_available(project_dir: str = ".") -> bool:
+    """Check if an ESDB exists for the given project."""
+    from pathlib import Path
+
+    esdb_dir = Path(project_dir).resolve() / ".chronomemory"
+    return (esdb_dir / "events.wal").is_file()

specsmith-0.10.1.dev294/src/specsmith/esdb/bridge.py

@@ -0,0 +1,137 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 Layer1Labs / BitConcepts, LLC.
+"""ESDB bridge — adapter between .specsmith/ JSON and ESDB concepts.
+
+This module provides read-only access to the current .specsmith/ flat JSON
+state through ESDB-compatible query interfaces. It allows specsmith's
+governance logic to work with either backend transparently.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class EsdbRecord:
+    """Python mirror of the Rust Record type."""
+
+    id: str
+    kind: str
+    status: str = "active"
+    confidence: float = 0.7
+    label: str = ""
+    data: dict[str, Any] = field(default_factory=dict)
+    source_ids: list[str] = field(default_factory=list)
+
+
+@dataclass
+class EsdbStatus:
+    """ESDB health status for the REST API."""
+
+    available: bool
+    backend: str  # "esdb" or "json-fallback"
+    record_count: int = 0
+    wal_seq: int = 0
+    epoch: int = 0
+    chain_valid: bool = True
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "available": self.available,
+            "backend": self.backend,
+            "record_count": self.record_count,
+            "wal_seq": self.wal_seq,
+            "epoch": self.epoch,
+            "chain_valid": self.chain_valid,
+        }
+
+
+class EsdbBridge:
+    """Read-only bridge to .specsmith/ JSON files using ESDB semantics.
+
+    When the Rust ESDB engine is available (via PyO3 bindings), this
+    class delegates to it. Otherwise, it reads the flat JSON files
+    directly and presents them through an ESDB-compatible interface.
+    """
+
+    def __init__(self, project_dir: str = ".") -> None:
+        self.root = Path(project_dir).resolve()
+        self._requirements: list[EsdbRecord] | None = None
+        self._testcases: list[EsdbRecord] | None = None
+
+    def status(self) -> EsdbStatus:
+        """Return ESDB status."""
+        reqs = self._load_requirements()
+        tests = self._load_testcases()
+        return EsdbStatus(
+            available=True,
+            backend="json-fallback",
+            record_count=len(reqs) + len(tests),
+        )
+
+    def requirements(self) -> list[EsdbRecord]:
+        """Load requirements as ESDB records."""
+        return self._load_requirements()
+
+    def testcases(self) -> list[EsdbRecord]:
+        """Load test cases as ESDB records."""
+        return self._load_testcases()
+
+    def record_counts(self) -> dict[str, int]:
+        """Record counts by kind (for dashboard)."""
+        return {
+            "requirements": len(self._load_requirements()),
+            "testcases": len(self._load_testcases()),
+        }
+
+    def _load_requirements(self) -> list[EsdbRecord]:
+        if self._requirements is not None:
+            return self._requirements
+        path = self.root / ".specsmith" / "requirements.json"
+        if not path.is_file():
+            self._requirements = []
+            return []
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+            self._requirements = [
+                EsdbRecord(
+                    id=r.get("id", ""),
+                    kind="requirement",
+                    label=r.get("title", ""),
+                    confidence=float(r.get("confidence", 0.7)),
+                    data=r,
+                )
+                for r in raw
+                if isinstance(r, dict)
+            ]
+        except (OSError, ValueError):
+            self._requirements = []
+        return self._requirements
+
+    def _load_testcases(self) -> list[EsdbRecord]:
+        if self._testcases is not None:
+            return self._testcases
+        path = self.root / ".specsmith" / "testcases.json"
+        if not path.is_file():
+            self._testcases = []
+            return []
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+            self._testcases = [
+                EsdbRecord(
+                    id=r.get("id", ""),
+                    kind="testcase",
+                    label=r.get("title", ""),
+                    confidence=float(r.get("confidence", 1.0)),
+                    data=r,
+                )
+                for r in raw
+                if isinstance(r, dict)
+            ]
+        except (OSError, ValueError):
+            self._testcases = []
+        return self._testcases

{specsmith-0.10.1.dev292 → specsmith-0.10.1.dev294}/src/specsmith/governance_logic.py

@@ -614,6 +614,24 @@ class GovernanceHTTPServer:
                     except Exception as exc:  # noqa: BLE001
                         self._json_err(str(exc), code=500)
 
+                # ── ESDB ──────────────────────────────────────────────
+                elif self.path == "/api/esdb/status":
+                    try:
+                        from specsmith.esdb.bridge import EsdbBridge
+
+                        bridge = EsdbBridge(project_dir)
+                        self._json_ok(bridge.status().to_dict())
+                    except Exception as exc:  # noqa: BLE001
+                        self._json_err(str(exc), code=500)
+                elif self.path == "/api/esdb/counts":
+                    try:
+                        from specsmith.esdb.bridge import EsdbBridge
+
+                        bridge = EsdbBridge(project_dir)
+                        self._json_ok(bridge.record_counts())
+                    except Exception as exc:  # noqa: BLE001
+                        self._json_err(str(exc), code=500)
+
                 # ── Datasources ────────────────────────────────────────
                 elif self.path == "/api/datasources":
                     try:

specsmith-0.10.1.dev294/src/specsmith/mcp_generator.py

@@ -0,0 +1,210 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 Layer1Labs / BitConcepts, LLC.
+"""MCP Server Generator — auto-scaffold Model Context Protocol servers.
+
+Generates Python MCP servers from natural-language tool descriptions using
+the FastMCP pattern. Each generated server includes a `server.py`,
+`tool_schema.json`, and `README.md`.
+
+Usage:
+    from specsmith.mcp_generator import generate_mcp_server, list_mcp_servers
+    server = generate_mcp_server("Search USPTO patents by keyword")
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class MCPServerSpec:
+    """Specification for a generated MCP server."""
+
+    id: str
+    name: str
+    description: str
+    tools: list[MCPToolSpec] = field(default_factory=list)
+    transport: str = "stdio"  # "stdio" or "http"
+    port: int = 8100
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "tools": [t.to_dict() for t in self.tools],
+            "transport": self.transport,
+            "port": self.port,
+        }
+
+
+@dataclass
+class MCPToolSpec:
+    """Specification for a single MCP tool."""
+
+    name: str
+    description: str
+    input_params: dict[str, str] = field(default_factory=dict)
+    output_type: str = "text"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "input_params": self.input_params,
+            "output_type": self.output_type,
+        }
+
+
+def _generate_server_id(name: str) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", name.lower().strip())[:30]
+    return f"mcp-{slug}-{uuid.uuid4().hex[:6]}"
+
+
+def _generate_server_py(spec: MCPServerSpec) -> str:
+    """Generate a Python MCP server file."""
+    tool_funcs = []
+    for tool in spec.tools:
+        params = ", ".join(f"{k}: str" for k in tool.input_params)
+        func = f'''
+@mcp.tool()
+def {tool.name}({params}) -> dict:
+    """{tool.description}"""
+    # TODO: implement actual logic
+    return {{"result": "stub response", "tool": "{tool.name}"}}
+'''
+        tool_funcs.append(func)
+
+    transport_line = (
+        f'    mcp.run(transport="streamable-http", host="127.0.0.1", port={spec.port})'
+        if spec.transport == "http"
+        else '    mcp.run(transport="stdio")'
+    )
+
+    return f'''#!/usr/bin/env python3
+# Auto-generated MCP server: {spec.name}
+# Generated by specsmith mcp generate
+
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("{spec.name}")
+{"".join(tool_funcs)}
+
+if __name__ == "__main__":
+{transport_line}
+'''
+
+
+def _generate_readme(spec: MCPServerSpec) -> str:
+    """Generate README.md for the MCP server."""
+    tool_list = "\n".join(f"- **{t.name}**: {t.description}" for t in spec.tools)
+    return f"""# {spec.name}
+
+{spec.description}
+
+## Tools
+
+{tool_list}
+
+## Usage
+
+```bash
+# stdio mode
+python server.py
+
+# HTTP mode (if configured)
+python server.py
+```
+
+## Configuration
+
+Add to your MCP client config:
+
+```json
+{{
+  "mcpServers": {{
+    "{spec.id}": {{
+      "command": "python",
+      "args": ["server.py"]
+    }}
+  }}
+}}
+```
+"""
+
+
+def generate_mcp_server(
+    tool_description: str,
+    project_dir: str = ".",
+    transport: str = "stdio",
+    port: int = 8100,
+) -> MCPServerSpec:
+    """Generate an MCP server from a natural-language tool description.
+
+    Creates a server directory with `server.py`, `tool_schema.json`, and `README.md`.
+    """
+    # Parse description into server + tool spec
+    name = tool_description.strip()[:50]
+    server_id = _generate_server_id(name)
+    tool_name = re.sub(r"[^a-z0-9_]+", "_", name.lower().strip())[:40]
+
+    tool = MCPToolSpec(
+        name=tool_name,
+        description=tool_description.strip(),
+        input_params={"query": "Search query or input"},
+    )
+
+    spec = MCPServerSpec(
+        id=server_id,
+        name=name,
+        description=tool_description.strip(),
+        tools=[tool],
+        transport=transport,
+        port=port,
+    )
+
+    # Create server directory
+    server_dir = Path(project_dir).resolve() / ".specsmith" / "mcp-servers" / server_id
+    server_dir.mkdir(parents=True, exist_ok=True)
+
+    # Write files
+    (server_dir / "server.py").write_text(_generate_server_py(spec), encoding="utf-8")
+    (server_dir / "tool_schema.json").write_text(
+        json.dumps(spec.to_dict(), indent=2, ensure_ascii=False), encoding="utf-8"
+    )
+    (server_dir / "README.md").write_text(_generate_readme(spec), encoding="utf-8")
+
+    return spec
+
+
+def list_mcp_servers(project_dir: str = ".") -> list[MCPServerSpec]:
+    """List all generated MCP servers."""
+    servers_dir = Path(project_dir).resolve() / ".specsmith" / "mcp-servers"
+    if not servers_dir.is_dir():
+        return []
+    servers: list[MCPServerSpec] = []
+    for server_dir in sorted(servers_dir.iterdir()):
+        schema_path = server_dir / "tool_schema.json"
+        if schema_path.is_file():
+            try:
+                raw = json.loads(schema_path.read_text(encoding="utf-8"))
+                servers.append(
+                    MCPServerSpec(
+                        id=raw.get("id", ""),
+                        name=raw.get("name", ""),
+                        description=raw.get("description", ""),
+                        transport=raw.get("transport", "stdio"),
+                        port=raw.get("port", 8100),
+                    )
+                )
+            except (OSError, ValueError):
+                continue
+    return servers
+
+
+__all__ = ["MCPServerSpec", "MCPToolSpec", "generate_mcp_server", "list_mcp_servers"]

specsmith-0.10.1.dev294/src/specsmith/skills_builder.py

@@ -0,0 +1,193 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 Layer1Labs / BitConcepts, LLC.
+"""AI-powered Skills Builder — generate agent skills from natural-language descriptions.
+
+Skills follow the SkillNet-style ontology: each skill is a folder containing
+a SKILL.md file with structured metadata (name, purpose, activation rules,
+input/output schema, epistemic contract, tools used, tests required).
+
+Usage:
+    from specsmith.skills_builder import build_skill, list_skills
+    skill = build_skill("Summarize a Python file into bullet points")
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class SkillSpec:
+    """Structured specification for an agent skill."""
+
+    id: str
+    name: str
+    purpose: str
+    activation_rules: list[str] = field(default_factory=list)
+    input_schema: dict[str, str] = field(default_factory=dict)
+    output_schema: dict[str, str] = field(default_factory=dict)
+    epistemic_contract: str = ""
+    tools_used: list[str] = field(default_factory=list)
+    tests_required: list[str] = field(default_factory=list)
+    stop_conditions: list[str] = field(default_factory=list)
+    tags: list[str] = field(default_factory=list)
+    active: bool = False
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "purpose": self.purpose,
+            "activation_rules": self.activation_rules,
+            "input_schema": self.input_schema,
+            "output_schema": self.output_schema,
+            "epistemic_contract": self.epistemic_contract,
+            "tools_used": self.tools_used,
+            "tests_required": self.tests_required,
+            "stop_conditions": self.stop_conditions,
+            "tags": self.tags,
+            "active": self.active,
+        }
+
+    def to_markdown(self) -> str:
+        """Generate SKILL.md content."""
+        lines = [
+            f"# {self.name}",
+            "",
+            f"**ID:** {self.id}",
+            f"**Purpose:** {self.purpose}",
+            "",
+            "## Activation Rules",
+            "",
+        ]
+        for rule in self.activation_rules:
+            lines.append(f"- {rule}")
+        lines.extend(
+            [
+                "",
+                "## Input Schema",
+                "",
+                "```json",
+                json.dumps(self.input_schema, indent=2),
+                "```",
+                "",
+                "## Output Schema",
+                "",
+                "```json",
+                json.dumps(self.output_schema, indent=2),
+                "```",
+                "",
+                "## Epistemic Contract",
+                "",
+                self.epistemic_contract or "No epistemic contract defined.",
+                "",
+                "## Tools Used",
+                "",
+            ]
+        )
+        for tool in self.tools_used:
+            lines.append(f"- {tool}")
+        lines.extend(["", "## Tests Required", ""])
+        for test in self.tests_required:
+            lines.append(f"- {test}")
+        lines.extend(["", "## Stop Conditions", ""])
+        for cond in self.stop_conditions:
+            lines.append(f"- {cond}")
+        return "\n".join(lines)
+
+
+def _generate_skill_id(name: str) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", name.lower().strip())[:30]
+    return f"skill-{slug}-{uuid.uuid4().hex[:6]}"
+
+
+def build_skill(
+    description: str,
+    project_dir: str = ".",
+    tags: list[str] | None = None,
+) -> SkillSpec:
+    """Build a skill from a natural-language description.
+
+    Currently generates a deterministic skill spec from the description.
+    When an AI provider is configured, this will use the LLM to generate
+    richer skill content.
+    """
+    # Deterministic generation (no LLM required)
+    name = description.strip()[:60]
+    skill_id = _generate_skill_id(name)
+
+    spec = SkillSpec(
+        id=skill_id,
+        name=name,
+        purpose=description.strip(),
+        activation_rules=[f"User requests: {description[:80]}"],
+        input_schema={"task": "string", "context": "string (optional)"},
+        output_schema={"result": "string", "confidence": "number"},
+        epistemic_contract="Output must be verifiable against the input task.",
+        tools_used=["read_file", "run_shell"],
+        tests_required=[f"Verify {name} produces correct output"],
+        stop_conditions=["Confidence below 0.3", "Timeout exceeded"],
+        tags=tags or [],
+    )
+
+    # Save to disk
+    skill_dir = Path(project_dir).resolve() / ".specsmith" / "skills" / skill_id
+    skill_dir.mkdir(parents=True, exist_ok=True)
+    (skill_dir / "SKILL.md").write_text(spec.to_markdown(), encoding="utf-8")
+
+    # Save JSON metadata
+    (skill_dir / "skill.json").write_text(
+        json.dumps(spec.to_dict(), indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+
+    return spec
+
+
+def list_skills(project_dir: str = ".") -> list[SkillSpec]:
+    """List all available skills in the project."""
+    skills_dir = Path(project_dir).resolve() / ".specsmith" / "skills"
+    if not skills_dir.is_dir():
+        return []
+    skills: list[SkillSpec] = []
+    for skill_dir in sorted(skills_dir.iterdir()):
+        meta_path = skill_dir / "skill.json"
+        if meta_path.is_file():
+            try:
+                raw = json.loads(meta_path.read_text(encoding="utf-8"))
+                skills.append(
+                    SkillSpec(
+                        id=raw.get("id", ""),
+                        name=raw.get("name", ""),
+                        purpose=raw.get("purpose", ""),
+                        activation_rules=raw.get("activation_rules", []),
+                        tools_used=raw.get("tools_used", []),
+                        tags=raw.get("tags", []),
+                        active=raw.get("active", False),
+                    )
+                )
+            except (OSError, ValueError):
+                continue
+    return skills
+
+
+def activate_skill(skill_id: str, project_dir: str = ".") -> bool:
+    """Activate a skill by ID."""
+    meta_path = Path(project_dir).resolve() / ".specsmith" / "skills" / skill_id / "skill.json"
+    if not meta_path.is_file():
+        return False
+    try:
+        raw = json.loads(meta_path.read_text(encoding="utf-8"))
+        raw["active"] = True
+        meta_path.write_text(json.dumps(raw, indent=2, ensure_ascii=False), encoding="utf-8")
+        return True
+    except (OSError, ValueError):
+        return False
+
+
+__all__ = ["SkillSpec", "activate_skill", "build_skill", "list_skills"]

{specsmith-0.10.1.dev292 → specsmith-0.10.1.dev294}/src/specsmith.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.10.1.dev292
+Version: 0.10.1.dev294
 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.10.1.dev292 → specsmith-0.10.1.dev294}/src/specsmith.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ src/specsmith/importer.py
 src/specsmith/instinct.py
 src/specsmith/languages.py
 src/specsmith/ledger.py
+src/specsmith/mcp_generator.py
 src/specsmith/patent.py
 src/specsmith/paths.py
 src/specsmith/phase.py
@@ -52,6 +53,7 @@ src/specsmith/serve.py
 src/specsmith/session.py
 src/specsmith/session_init.py
 src/specsmith/skills.py
+src/specsmith/skills_builder.py
 src/specsmith/sync.py
 src/specsmith/tool_installer.py
 src/specsmith/toolrules.py
@@ -115,6 +117,8 @@ src/specsmith/epistemic/certainty.py
 src/specsmith/epistemic/failure_graph.py
 src/specsmith/epistemic/recovery.py
 src/specsmith/epistemic/stress_tester.py
+src/specsmith/esdb/__init__.py
+src/specsmith/esdb/bridge.py
 src/specsmith/eval/__init__.py
 src/specsmith/eval/builtins.py
 src/specsmith/eval/runner.py
@@ -218,6 +222,7 @@ tests/test_phase34_completion.py
 tests/test_rate_limits.py
 tests/test_scaffolder.py
 tests/test_skill_marketplace.py
+tests/test_skills_mcp.py
 tests/test_smoke.py
 tests/test_suggester.py
 tests/test_tools.py