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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: capability-compiler
-Version: 0.1.0
+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.0 → 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.0"
+__version__ = "0.1.2"

{capability_compiler-0.1.0 → 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.0 → capability_compiler-0.1.2}/src/capability_compiler/cli/_common.py

@@ -33,6 +33,7 @@ __all__ = [
     "parse_key_path",
     "parse_key_value",
     "run_async",
+    "seed_fake_demo",
 ]
 
 
@@ -133,3 +134,26 @@ def parse_key_path(key_path: str) -> list[str]:
         msg = f"key.path must be 'section.key' (min 2 segments), got {key_path!r}"
         raise ValueError(msg)
     return parts
+
+
+# -- fake-adapter demo seeding ----------------------------------------------------
+
+
+def seed_fake_demo(adapter_obj: Any, url: str) -> bool:
+    """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
+    elements a learned capability refers to don't exist). When (and only
+    when) the attached adapter is the in-memory FakeAdapter, plant a
+    deterministic three-element demo page (Docs link, Search box, Submit
+    button) so the full learn → compile → persist → execute loop works
+    offline out of the box. Real adapters (browser/desktop) are never
+    touched.
+
+    Returns:
+        ``True`` when the demo page was planted, ``False`` otherwise.
+    """
+    from capability_compiler.adapters.fake_adapter import seed_demo_page
+
+    return seed_demo_page(adapter_obj, url)

{capability_compiler-0.1.0 → capability_compiler-0.1.2}/src/capability_compiler/cli/execute_cmd.py

@@ -27,6 +27,7 @@ from capability_compiler.cli._common import (
     load_registry,
     load_settings_cached,
     run_async,
+    seed_fake_demo,
 )
 from capability_compiler.errors import CapabilityCompilerError, PermissionDeniedError
 
@@ -117,6 +118,9 @@ def execute(
     compiler = _build_compiler(settings, adapter)
     try:
         run_async(compiler.connect())
+        # Give the offline fake adapter the same demo page the capability was
+        # learned from, so its preconditions (element presence) can hold.
+        seed_fake_demo(getattr(compiler, "adapter", None), _start_url(capability))
         result = run_async(compiler.execute(capability, inputs, confirmed=confirmed))
     except CapabilityCompilerError as exc:
         _fail(exc, json_mode=json_mode)
@@ -171,6 +175,17 @@ def _build_compiler(settings: Any, adapter: str) -> Any:
     return Compiler(settings, adapter_kind=adapter)
 
 
+def _start_url(capability: Any) -> str:
+    """First navigation URL in the capability's procedure (fallback: app://x)."""
+    from capability_compiler.models.action import NavigateAction
+
+    for step in capability.procedure.steps:
+        action = getattr(step, "action", None)
+        if isinstance(action, NavigateAction):
+            return action.url
+    return "app://x"
+
+
 def _render_execution(result: Any) -> None:
     typer.echo(f"# {result.capability} @ {result.version} — {result.status.value}")
     typer.echo(f"  duration_ms: {result.duration_ms:.1f}")

{capability_compiler-0.1.0 → capability_compiler-0.1.2}/src/capability_compiler/cli/learn_cmd.py

@@ -22,6 +22,7 @@ from capability_compiler.cli._common import (
     _wants_json,
     load_settings_cached,
     run_async,
+    seed_fake_demo,
 )
 from capability_compiler.errors import CapabilityCompilerError
 from capability_compiler.models.action import NavigateAction
@@ -61,7 +62,11 @@ def learn(
         run_async(compiler.connect())
         try:
             target_url = start_url or url
-            if _can_navigate(compiler):
+            if seed_fake_demo(getattr(compiler, "adapter", None), target_url):
+                # The demo page already set the URL; navigating again would
+                # be a no-op on the fake adapter.
+                pass
+            elif _can_navigate(compiler):
                 run_async(
                     compiler.adapter.execute(NavigateAction(url=target_url))
                     if compiler.adapter

{capability_compiler-0.1.0 → 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.0 → capability_compiler-0.1.2}/src/capability_compiler/synthesis/engine.py

@@ -31,6 +31,7 @@ from __future__ import annotations
 import re
 from typing import TYPE_CHECKING, Any
 
+from capability_compiler.errors import CapabilityCompilerError
 from capability_compiler.logging import StructuredLogAdapter, get_logger
 from capability_compiler.models import (
     AssertionKind,
@@ -145,6 +146,24 @@ class CapabilitySynthesizer:
 
         effects = self._derive_effects(hypotheses)
 
+        if not procedure_steps:
+            # Nothing demonstrable happened: the trajectory had no successful
+            # actions to compile (empty environment, exploration cut short,
+            # or every step failed). A capability with an empty procedure is
+            # invalid (it could never execute), so fail loudly with guidance
+            # instead of surfacing a raw pydantic validation error.
+            raise CapabilityCompilerError(
+                "no successful actions in trajectory: cannot compile a capability "
+                "from an empty procedure — record at least one successful action "
+                "(check that the target environment exposes interactive elements)",
+                code="synthesis.empty_procedure",
+                context={
+                    "trajectory_id": trajectory.trajectory_id,
+                    "total_steps": len(trajectory.steps),
+                    "skipped_steps": report.skipped_steps,
+                },
+            )
+
         capability = Capability(
             name=name,
             description=description,
@@ -267,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,
                 )
@@ -279,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.0 → 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.0 → 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)