specsmith 0.10.1.dev293__tar.gz → 0.10.1.dev295__tar.gz

{specsmith-0.10.1.dev293 → specsmith-0.10.1.dev295}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsmith"
-version = "0.10.1.dev293"
+version = "0.10.1.dev295"
 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.dev293 → specsmith-0.10.1.dev295}/src/specsmith/governance_logic.py

@@ -614,6 +614,46 @@ class GovernanceHTTPServer:
                     except Exception as exc:  # noqa: BLE001
                         self._json_err(str(exc), code=500)
 
+                # ── Skills ───────────────────────────────────────────
+                elif self.path == "/api/skills":
+                    try:
+                        from specsmith.skills_builder import list_skills
+
+                        skills = list_skills(project_dir)
+                        self._json_ok({"skills": [s.to_dict() for s in skills]})
+                    except Exception as exc:  # noqa: BLE001
+                        self._json_err(str(exc), code=500)
+
+                # ── Eval ────────────────────────────────────────────
+                elif self.path == "/api/eval/suites":
+                    try:
+                        from specsmith.eval.builtins import list_suites
+
+                        suites = list_suites()
+                        self._json_ok({"suites": [s.to_dict() for s in suites]})
+                    except Exception as exc:  # noqa: BLE001
+                        self._json_err(str(exc), code=500)
+
+                # ── Teams ───────────────────────────────────────────
+                elif self.path == "/api/teams":
+                    try:
+                        from specsmith.agent.teams import list_teams
+
+                        teams = list_teams()
+                        self._json_ok({"teams": [t.to_dict() for t in teams]})
+                    except Exception as exc:  # noqa: BLE001
+                        self._json_err(str(exc), code=500)
+
+                # ── MCP Servers ─────────────────────────────────────
+                elif self.path == "/api/mcp/servers":
+                    try:
+                        from specsmith.mcp_generator import list_mcp_servers
+
+                        servers = list_mcp_servers(project_dir)
+                        self._json_ok({"servers": [s.to_dict() for s in servers]})
+                    except Exception as exc:  # noqa: BLE001
+                        self._json_err(str(exc), code=500)
+
                 # ── ESDB ──────────────────────────────────────────────
                 elif self.path == "/api/esdb/status":
                     try:

specsmith-0.10.1.dev295/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.dev295/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.dev293 → specsmith-0.10.1.dev295}/src/specsmith.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.10.1.dev293
+Version: 0.10.1.dev295
 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.dev293 → specsmith-0.10.1.dev295}/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
@@ -220,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

specsmith-0.10.1.dev295/tests/test_skills_mcp.py

@@ -0,0 +1,109 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 Layer1Labs / BitConcepts, LLC.
+"""Tests for Skills Builder and MCP Server Generator."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+class TestSkillsBuilder:
+    def test_build_skill(self, tmp_path: Path) -> None:
+        from specsmith.skills_builder import build_skill
+
+        skill = build_skill("Summarize Python files into bullet points", str(tmp_path))
+        assert skill.id.startswith("skill-")
+        assert skill.name == "Summarize Python files into bullet points"
+        assert skill.purpose
+        assert len(skill.activation_rules) > 0
+
+    def test_skill_saved_to_disk(self, tmp_path: Path) -> None:
+        from specsmith.skills_builder import build_skill
+
+        skill = build_skill("Analyze code complexity", str(tmp_path))
+        skill_dir = tmp_path / ".specsmith" / "skills" / skill.id
+        assert (skill_dir / "SKILL.md").is_file()
+        assert (skill_dir / "skill.json").is_file()
+        content = (skill_dir / "SKILL.md").read_text(encoding="utf-8")
+        assert "Analyze code complexity" in content
+
+    def test_list_skills_empty(self, tmp_path: Path) -> None:
+        from specsmith.skills_builder import list_skills
+
+        assert list_skills(str(tmp_path)) == []
+
+    def test_list_skills_after_build(self, tmp_path: Path) -> None:
+        from specsmith.skills_builder import build_skill, list_skills
+
+        build_skill("Skill A", str(tmp_path))
+        build_skill("Skill B", str(tmp_path))
+        skills = list_skills(str(tmp_path))
+        assert len(skills) == 2
+
+    def test_activate_skill(self, tmp_path: Path) -> None:
+        from specsmith.skills_builder import activate_skill, build_skill, list_skills
+
+        skill = build_skill("Activatable skill", str(tmp_path))
+        assert not skill.active
+        assert activate_skill(skill.id, str(tmp_path))
+        skills = list_skills(str(tmp_path))
+        assert any(s.active for s in skills)
+
+    def test_skill_to_dict(self) -> None:
+        from specsmith.skills_builder import SkillSpec
+
+        spec = SkillSpec(id="test", name="Test", purpose="Testing")
+        d = spec.to_dict()
+        assert d["id"] == "test"
+        assert d["name"] == "Test"
+
+
+class TestMCPGenerator:
+    def test_generate_server(self, tmp_path: Path) -> None:
+        from specsmith.mcp_generator import generate_mcp_server
+
+        spec = generate_mcp_server("Search USPTO patents by keyword", str(tmp_path))
+        assert spec.id.startswith("mcp-")
+        assert len(spec.tools) == 1
+        assert spec.transport == "stdio"
+
+    def test_server_files_created(self, tmp_path: Path) -> None:
+        from specsmith.mcp_generator import generate_mcp_server
+
+        spec = generate_mcp_server("Lookup weather data", str(tmp_path))
+        server_dir = tmp_path / ".specsmith" / "mcp-servers" / spec.id
+        assert (server_dir / "server.py").is_file()
+        assert (server_dir / "tool_schema.json").is_file()
+        assert (server_dir / "README.md").is_file()
+
+    def test_server_py_contains_tool(self, tmp_path: Path) -> None:
+        from specsmith.mcp_generator import generate_mcp_server
+
+        spec = generate_mcp_server("Calculate BMI", str(tmp_path))
+        server_dir = tmp_path / ".specsmith" / "mcp-servers" / spec.id
+        content = (server_dir / "server.py").read_text(encoding="utf-8")
+        assert "FastMCP" in content
+        assert "@mcp.tool()" in content
+
+    def test_list_servers_empty(self, tmp_path: Path) -> None:
+        from specsmith.mcp_generator import list_mcp_servers
+
+        assert list_mcp_servers(str(tmp_path)) == []
+
+    def test_list_servers_after_generate(self, tmp_path: Path) -> None:
+        from specsmith.mcp_generator import generate_mcp_server, list_mcp_servers
+
+        generate_mcp_server("Tool A", str(tmp_path))
+        generate_mcp_server("Tool B", str(tmp_path))
+        servers = list_mcp_servers(str(tmp_path))
+        assert len(servers) == 2
+
+    def test_http_transport(self, tmp_path: Path) -> None:
+        from specsmith.mcp_generator import generate_mcp_server
+
+        spec = generate_mcp_server("HTTP tool", str(tmp_path), transport="http", port=9000)
+        assert spec.transport == "http"
+        assert spec.port == 9000
+        server_dir = tmp_path / ".specsmith" / "mcp-servers" / spec.id
+        content = (server_dir / "server.py").read_text(encoding="utf-8")
+        assert "streamable-http" in content