capability-compiler 0.1.1__tar.gz → 0.1.2__tar.gz

{capability_compiler-0.1.1 → capability_compiler-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: capability-compiler
-Version: 0.1.1
+Version: 0.1.2
 Summary: Turn any software into an API for AI: compile interaction trajectories into verified, reusable capabilities exposed via Python, CLI, and MCP.
 Project-URL: Homepage, https://github.com/capability-compiler/capability-compiler
 Project-URL: Documentation, https://github.com/capability-compiler/capability-compiler/tree/main/docs

{capability_compiler-0.1.1 → capability_compiler-0.1.2}/src/capability_compiler/_version.py

@@ -5,4 +5,4 @@ without importing the whole package (pyproject reads it at build time via
 hatchling's version hook — see ``[tool.hatch.version]``).
 """
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"

{capability_compiler-0.1.1 → capability_compiler-0.1.2}/src/capability_compiler/adapters/fake_adapter.py

@@ -96,6 +96,46 @@ class FakeAdapter:
 
     # -- test/Bench helpers -----------------------------------------------------
 
+    def seed_demo_page(self, *, url: str = "demo://page", title: str = "Demo Page") -> None:
+        """Plant the deterministic three-element demo page.
+
+        A bare fake adapter starts empty — exploration has nothing to
+        compile and execution fails its preconditions (the elements a
+        learned capability refers to don't exist). This page (a Docs link,
+        a Search box, a Submit button) is the canonical offline demo
+        environment: ``cc learn``/``cc execute`` and the MCP server's
+        default executor all seed it so the full
+        learn → compile → persist → execute loop works with zero setup.
+        """
+        self.set_state(
+            url=url,
+            title=title,
+            elements=[
+                InteractiveElement(
+                    element_id="nav_docs",
+                    ref="nav-docs",
+                    role="link",
+                    name="Docs",
+                    action_hints=["click"],
+                ),
+                InteractiveElement(
+                    element_id="search_box",
+                    ref="search-box",
+                    role="searchbox",
+                    name="Search",
+                    action_hints=["type", "click"],
+                ),
+                InteractiveElement(
+                    element_id="submit_btn",
+                    ref="submit-btn",
+                    role="button",
+                    name="Submit",
+                    action_hints=["click"],
+                ),
+            ],
+            text_digest="demo page with docs link, search box, and submit button",
+        )
+
     def set_state(
         self,
         *,
@@ -227,6 +267,21 @@ class FakeAdapter:
 # -- registration ---------------------------------------------------------------
 
 
+def seed_demo_page(adapter: Any, url: str) -> bool:
+    """Seed *adapter* with the demo page when (and only when) it is a FakeAdapter.
+
+    Real adapters (browser/desktop) are never touched — their state belongs
+    to the live environment. Returns ``True`` when the demo page was planted.
+
+    The query string is stripped so ``https://example.com/docs?q=x`` and
+    ``https://example.com/docs`` land on the same deterministic page.
+    """
+    if not isinstance(adapter, FakeAdapter):
+        return False
+    adapter.seed_demo_page(url=url.rsplit("?", 1)[0])
+    return True
+
+
 def _factory(settings: Any | None = None) -> FakeAdapter:
     return FakeAdapter(settings)
 
@@ -234,7 +289,7 @@ def _factory(settings: Any | None = None) -> FakeAdapter:
 register_adapter("fake", _factory, description=FakeAdapter.description, replace=True)
 
 
-__all__ = ["FakeAdapter"]
+__all__ = ["FakeAdapter", "seed_demo_page"]
 
 
 def id_for(prefix: str = "fake") -> str:

{capability_compiler-0.1.1 → capability_compiler-0.1.2}/src/capability_compiler/cli/_common.py

@@ -140,7 +140,7 @@ def parse_key_path(key_path: str) -> list[str]:
 
 
 def seed_fake_demo(adapter_obj: Any, url: str) -> bool:
-    """Seed a FakeAdapter with a small demo page so the pipeline has work.
+    """Seed a FakeAdapter with the small demo page so the pipeline has work.
 
     The fake adapter starts empty — with no interactive elements exploration
     runs dry (nothing to compile) and execution fails its preconditions (the
@@ -154,38 +154,6 @@ def seed_fake_demo(adapter_obj: Any, url: str) -> bool:
     Returns:
         ``True`` when the demo page was planted, ``False`` otherwise.
     """
-    if type(adapter_obj).__name__ != "FakeAdapter":
-        return False
-    from capability_compiler.models import InteractiveElement
-
-    page = url.rsplit("?", 1)[0]
-    elements = [
-        InteractiveElement(
-            element_id="nav_docs",
-            ref="nav-docs",
-            role="link",
-            name="Docs",
-            action_hints=["click"],
-        ),
-        InteractiveElement(
-            element_id="search_box",
-            ref="search-box",
-            role="searchbox",
-            name="Search",
-            action_hints=["type", "click"],
-        ),
-        InteractiveElement(
-            element_id="submit_btn",
-            ref="submit-btn",
-            role="button",
-            name="Submit",
-            action_hints=["click"],
-        ),
-    ]
-    adapter_obj.set_state(
-        url=page,
-        title="Demo Page",
-        elements=elements,
-        text_digest="demo page with docs link, search box, and submit button",
-    )
-    return True
+    from capability_compiler.adapters.fake_adapter import seed_demo_page
+
+    return seed_demo_page(adapter_obj, url)

{capability_compiler-0.1.1 → capability_compiler-0.1.2}/src/capability_compiler/server/executor_factory.py

@@ -49,12 +49,16 @@ def build_default_factory() -> ExecutorFactory:
 
     The default keeps the MCP server runnable end-to-end with zero setup so
     `cc doctor`-style smoke tests succeed even before a real adapter is
-    registered. Production deployments should override this with the real
-    adapter (browser/desktop) at the CLI wiring layer.
+    registered. The adapter is seeded with the same demo page ``cc learn``
+    uses offline, so capabilities learned from that page hold their
+    preconditions when invoked over MCP. Production deployments should
+    override this with the real adapter (browser/desktop) at the CLI wiring
+    layer.
     """
 
     def factory(settings: CompilerSettings) -> CapabilityExecutor:
         adapter = FakeAdapter(settings)
+        adapter.seed_demo_page()
         log.debug(
             "executor_factory.default_built",
             extra={"extra_fields": {"adapter": adapter.kind}},

{capability_compiler-0.1.1 → capability_compiler-0.1.2}/src/capability_compiler/synthesis/engine.py

@@ -286,7 +286,13 @@ class CapabilitySynthesizer:
                     name=pname,
                     type="string",
                     description=f"Value for '{element_name}'",
-                    required=True,
+                    # The recorded literal is the default ("literals become
+                    # defaults, not guesses"): callers may omit the input and
+                    # the executor/template binder falls back to it. Keeping
+                    # required=True here would contradict the default and make
+                    # MCP tool calls with omitted arguments fail SDK-side
+                    # validation before the executor could apply the default.
+                    required=False,
                     default=action.text,
                     example=action.text,
                 )
@@ -298,7 +304,7 @@ class CapabilitySynthesizer:
                     name=pname,
                     type="string",
                     description=f"Selected value for '{element_name}'",
-                    required=True,
+                    required=False,  # recorded literal is the default (see above)
                     default=action.value,
                     example=action.value,
                 )

{capability_compiler-0.1.1 → capability_compiler-0.1.2}/tests/test_mcp_server.py

@@ -29,6 +29,7 @@ from capability_compiler.models import (
     NavigateAction,
     PermissionScope,
     ProcedureStep,
+    TypeAction,
 )
 from capability_compiler.registry import CapabilityRegistry
 from capability_compiler.server import (
@@ -233,6 +234,62 @@ class TestExecuteTool:
         assert "navigate" in captured["adapter"].calls
         assert "click" in captured["adapter"].calls
 
+    async def test_default_factory_runs_demo_capability_with_omitted_inputs(
+        self, tmp_path: Path
+    ) -> None:
+        """Regression: demo-learned capabilities run over MCP with no args.
+
+        Two bugs used to break this path: synthesis emitted
+        ``required=True`` alongside the recorded default (empty ``arguments``
+        failed the SDK-side validation before the executor could apply the
+        default), and the default executor factory built a bare FakeAdapter
+        (preconditions like "'Search' is present" failed because the demo
+        page ``cc learn`` compiles from was never seeded server-side).
+        """
+        registry = CapabilityRegistry.from_settings(_settings(tmp_path))
+        await registry.save(
+            _make_capability(
+                name="demo_search",
+                inputs=[
+                    CapabilityParameter(
+                        name="search",
+                        type="string",
+                        description="Value for 'Search'",
+                        required=False,
+                        default="hello",
+                    )
+                ],
+                procedure=CapabilityProcedure(
+                    steps=[
+                        ProcedureStep(
+                            step_id="s1",
+                            action=TypeAction(
+                                target=ActionTarget(
+                                    ref="search-box", role="searchbox", name="Search"
+                                ),
+                                text="{{search}}",
+                            ),
+                        ),
+                        ProcedureStep(
+                            step_id="s2",
+                            action=ClickAction(
+                                target=ActionTarget(
+                                    ref="submit-btn", role="button", name="Submit"
+                                )
+                            ),
+                        ),
+                    ]
+                ),
+            )
+        )
+        # Default factory: bare FakeAdapter + demo page, as `cc serve` uses it.
+        server = CapabilityMCPServer(registry, _settings(tmp_path))
+        result = await server.execute_tool("demo_search", {})
+        assert result["isError"] is False, result["content"][0]["text"]
+        body = json.loads(result["content"][0]["text"])
+        assert body["status"] == "success"
+        assert all(step["success"] for step in body["steps"])
+
     async def test_ping_returns_health_payload(self, tmp_path: Path) -> None:
         registry = CapabilityRegistry.from_settings(_settings(tmp_path))
         await registry.save(_make_capability(name="alpha"))

{capability_compiler-0.1.1 → capability_compiler-0.1.2}/tests/test_synthesis.py

@@ -146,6 +146,34 @@ class TestSynthesis:
         assert params["format"].default == "png"
         assert params["file_name"].default == "report"
 
+    async def test_recorded_parameters_are_optional(self):
+        """Recorded literals become defaults, not required inputs.
+
+        Regression: synthesis used to emit ``required=True`` alongside the
+        recorded default. The executor applies defaults when a caller omits
+        the input, so ``required`` contradicted ``default`` — and the MCP
+        tool built from the capability rejected empty-args calls at the SDK
+        validation layer before the executor could fill the default in.
+        """
+        app = ExportFakeApp()
+        trajectory, initial, final = await record_export_workflow(app)
+        capability = await CapabilitySynthesizer(use_model=False).synthesize(
+            trajectory, initial_observation=initial, final_observation=final
+        )
+
+        params = {p.name: p for p in capability.inputs}
+        assert params["format"].required is False
+        assert params["file_name"].required is False
+
+        # The MCP wire schema mirrors the contract: nothing required, the
+        # recorded literal surfaced as the JSON-Schema default.
+        from capability_compiler.server.tool_defs import build_input_schema
+
+        schema = build_input_schema(capability)
+        assert schema.get("required", []) == []
+        assert schema["properties"]["format"]["default"] == "png"
+        assert schema["properties"]["file_name"]["default"] == "report"
+
     async def test_preconditions_derived(self):
         app = ExportFakeApp()
         trajectory, initial, final = await record_export_workflow(app)