@passioncode-ai/passioncode 0.1.8 → 0.1.10

package/payload/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/sample_service.py

@@ -3,6 +3,9 @@
 
 It is the worked example the skill points at, the target check_service.py tests
 itself against, and the fixture Fabric Dashboards runs its end-to-end tests on.
+Over MCP (fabric-interop/0.1) it serves two capabilities: `sample.echo` answers at
+once, and `sample.draft` is a job that stops for a titled choice before it completes.
+`register` also writes the service's manifest, which names this descriptor.
 
   sample_service.py serve --port 47190 --data-dir DIR [--id sample] [--instance default]
   sample_service.py register --port 47190 --data-dir DIR [--services-dir DIR]
@@ -11,6 +14,7 @@ itself against, and the fixture Fabric Dashboards runs its end-to-end tests on.
 from __future__ import annotations
 
 import argparse
+import hashlib
 import html
 import json
 import os
@@ -24,6 +28,7 @@ from urllib.parse import parse_qs, urlparse
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 import fabric_service as fs  # noqa: E402
+import fabric_interop as fi  # noqa: E402
 
 VERSION = "0.1.0"
 PAGE = """<!doctype html><html lang="en"><head><meta charset="utf-8">
@@ -32,6 +37,24 @@ PAGE = """<!doctype html><html lang="en"><head><meta charset="utf-8">
 </head><body><h1>{name}</h1><p>Status: {status}</p><ul>{rows}</ul></body></html>"""
 
 
+def _schema(name: str, body: Dict[str, Any]) -> Dict[str, Any]:
+    return {"$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "urn:fabric:schema:%s" % name, **body}
+
+
+TEXT = {"type": "object", "additionalProperties": False, "properties": {"text": {"type": "string", "maxLength": 2000}}, "required": ["text"]}
+CAPABILITIES = [
+    {"name": "sample.echo", "effect": "none", "idempotency": "required", "job": False,
+     "description": "Returns the text it was given.",
+     "input": _schema("sample.echo-input", TEXT), "output": _schema("sample.echo-output", TEXT)},
+    {"name": "sample.draft", "effect": "draft", "idempotency": "none", "job": True,
+     "description": "Drafts a short note on a topic; asks which title to use.",
+     "input": _schema("sample.draft-input", {"type": "object", "additionalProperties": False,
+                                               "properties": {"topic": {"type": "string", "minLength": 1, "maxLength": 200}}, "required": ["topic"]}),
+     "output": _schema("sample.draft-output", {"type": "object", "additionalProperties": False,
+                                                 "properties": {"title": {"type": "string"}, "body": {"type": "string"}}, "required": ["title", "body"]})},
+]
+
+
 class Service:
     def __init__(self, args: argparse.Namespace):
         self.id = args.id
@@ -50,14 +73,59 @@ class Service:
         self.token = fs.ensure_token(self.token_file)
         self.log = fs.JsonlEventLog(self.data / "events.jsonl")
         self.codes = fs.LoginCodes(self.data / "auth")
+        self.jobs = fi.JobStore(self.data / "jobs")
+        self.mcp = fi.McpToolServer(self.id, VERSION, jobs=self.jobs, on_job_started=self.draft_started, on_input=self.draft_answered)
+        for cap in CAPABILITIES:
+            handler = self.echo if cap["name"] == "sample.echo" else self.draft
+            self.mcp.add_tool(fi.tool_for_capability(cap, cap["input"], cap["output"]), handler)
         self.log.append("service.started", "info", "%s started on build %s." % (self.name, self.build["commit"]))
 
+    # --- fabric-interop/0.1: the two capabilities ------------------------------------
+    def echo(self, args: Dict[str, Any], ctx: fi.CallContext) -> Dict[str, Any]:
+        if not isinstance(args.get("text"), str):
+            raise fi.InteropError("sample.echo needs text.")
+        return {"text": args["text"]}
+
+    def draft(self, args: Dict[str, Any], ctx: fi.CallContext) -> Dict[str, Any]:
+        if not isinstance(args.get("topic"), str) or not args["topic"].strip():
+            raise fi.InteropError("sample.draft needs a topic.")
+        return ctx.start_job(poll_interval_ms=1000)
+
+    def draft_started(self, job_id: str, ctx: fi.CallContext) -> None:
+        topic = str(ctx.arguments.get("topic"))
+        titles = [("plain", "About %s" % topic), ("question", "What is %s?" % topic)]
+        self.jobs.request_input(job_id, {"title_choice": fi.choice_request("Pick the title for the note.", "title", titles, "Title")},
+                                "Two titles are ready.")
+        self.log.append("job.awaiting_choice", "notice", "A note about %s is waiting for you to pick its title." % topic,
+                        notify=True, **fi.trace_ids(ctx.traceparent))
+
+    def draft_answered(self, job_id: str, answers: Dict[str, Any], ctx: fi.CallContext) -> None:
+        answer = answers.get("title_choice", {})
+        topic = str(ctx.arguments.get("topic"))
+        if answer.get("action") != "accept":
+            self.jobs.cancel(job_id)
+            self.log.append("job.cancelled", "info", "The note about %s was dropped: no title was chosen." % topic, **fi.trace_ids(ctx.traceparent))
+            return
+        choice = str((answer.get("content") or {}).get("title"))
+        title = "About %s" % topic if choice == "plain" else "What is %s?" % topic
+        body = "%s. This sample note was written by the sample service." % title
+        self.jobs.complete(job_id, fi.result_envelope(
+            outcome="partial", traceparent=ctx.traceparent,
+            producer={"id": "urn:fabric:provider:%s" % self.id, "revision": 1, "contentHash": "sha256:" + "0" * 64},
+            done=[{"claimId": "NOTE", "statement": "A note titled %s was drafted." % title}], proof=[],
+            scope={"project": "urn:fabric:project:sample", "run": "urn:fabric:run:%s" % job_id, "node": "urn:fabric:node:draft",
+                   "binding": {"id": "urn:fabric:binding:sample.draft", "revision": 1, "contentHash": "sha256:" + "0" * 64}, "writeScopes": []},
+            not_verified=[{"claim": "NOTE", "reason": "no checker has read the note"}],
+            output={"title": title, "body": body}, usage={"inputTokens": 0, "outputTokens": 0, "wallMs": 1}))
+        self.log.append("job.completed", "info", "The note %s is drafted." % title, **fi.trace_ids(ctx.traceparent))
+
     def well_known(self) -> Dict[str, Any]:
         return fs.build_well_known(
             service_id=self.id, instance=self.instance, name=self.name, version=VERSION, build=self.build,
             started_at=self.started_at, status="ready", degraded=self.degraded,
             summary=[{"label": "Events", "value": len(self.log.fetch(None, fs.EVENTS_MAX_LIMIT))}],
-            surfaces={"dashboard": {"path": "/", "login": True}, "events": {"path": "/fabric/v1/events"}},
+            surfaces={"dashboard": {"path": "/", "login": True}, "events": {"path": "/fabric/v1/events"},
+                      "mcp": {"path": "/mcp", "transport": "streamable-http", "capabilities": [c["name"] for c in CAPABILITIES]}},
         )
 
 
@@ -137,6 +205,16 @@ def make_handler(svc: Service):
             if not self._guard():
                 return
             url = urlparse(self.path)
+            if url.path == "/mcp":
+                if not self._token_ok():
+                    return
+                length = min(int(self.headers.get("Content-Length") or 0), 1048576)
+                try:
+                    message = json.loads(self.rfile.read(length) or b"null")
+                except ValueError:
+                    return self._send(400, {"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": "Parse error."}})
+                response = svc.mcp.handle(message)
+                return self._send(202) if response is None else self._send(200, response)
             if url.path == "/fabric/v1/login-code":
                 if not self._token_ok():
                     return
@@ -180,8 +258,46 @@ def serve(args: argparse.Namespace) -> int:
     return 0
 
 
+def write_manifest(args: argparse.Namespace, data: Path) -> Path:
+    """The provider manifest for this service, naming its descriptor (G-07), with its schemas beside it."""
+    schemas = data / "fabric" / "schemas"
+    for cap in CAPABILITIES:
+        for side in ("input", "output"):
+            fs.atomic_write(schemas / ("%s-%s.schema.json" % (cap["name"], side)),
+                            (json.dumps(cap[side], indent=2) + "\n").encode(), 0o600)
+    origin = "http://127.0.0.1:%d" % args.port
+    capabilities = []
+    for cap in CAPABILITIES:
+        capabilities.append({
+            "id": "urn:fabric:capability:%s" % cap["name"], "name": cap["name"], "description": cap["description"],
+            "inputSchema": cap["input"]["$id"], "outputSchema": cap["output"]["$id"],
+            "effect": cap["effect"], "idempotency": cap["idempotency"], "dataClasses": ["public"],
+            "profile": {"kind": "mcp", "protocolRevision": fi.MCP_REVISION,
+                        "connection": {"mode": "streamable-http", "url": origin + "/mcp"},
+                        "requiredFeatures": ["tool:%s" % cap["name"]],
+                        "probes": [{"id": "%s-shape" % cap["name"].replace(".", "-"), "inputFixture": "urn:fabric:fixture:%s" % cap["name"],
+                                    "outputSchema": cap["output"]["$id"], "timeoutMs": 5000, "sideEffectCeiling": "none",
+                                    "assertions": ["returns a value valid against its output schema"]}]},
+            "extensions": {fi.EXTENSION_KEY: {"job": cap["job"]}},
+        })
+    digest = hashlib.sha256(json.dumps(capabilities, sort_keys=True).encode()).hexdigest()
+    subject = "urn:fabric:provider:%s" % args.id
+    manifest = {
+        "contractVersion": "0.1.0",
+        "provider": {"id": subject, "revision": 1, "contentHash": "sha256:" + digest, "createdAt": fs.now_iso(),
+                     "createdBy": "urn:fabric:adapter:sample-service", "name": args.name,
+                     "identity": {"subject": subject, "method": "local-install"}, "supportedContractVersions": ["0.1.0"],
+                     "extensions": {fs.EXTENSION_KEY: {"descriptor": "%s.%s" % (args.id, args.instance)}}},
+        "capabilities": capabilities,
+    }
+    path = data / "fabric-agent.json"
+    fs.atomic_write(path, (json.dumps(manifest, indent=2) + "\n").encode(), 0o600)
+    return path
+
+
 def register(args: argparse.Namespace) -> int:
     data = Path(args.data_dir)
+    manifest = write_manifest(args, data)
     descriptor = {
         "protocol": fs.PROTOCOL, "id": args.id, "instance": args.instance, "name": args.name,
         "summary": "Sample fabric-service/0.1 service.",
@@ -190,6 +306,7 @@ def register(args: argparse.Namespace) -> int:
         "lifecycle": {"manager": "launchd", "label": args.label, "plist": args.plist} if args.label
         else {"manager": "none"},
         "paths": {"data": str(data), "logs": []},
+        "fabricManifest": str(manifest),
         "installedAt": fs.now_iso(), "installedBy": "sample_service.py register",
     }
     try:

package/payload/plugins/fabric-agent-adapter/skills/creating-fabric-agents/SKILL.md

@@ -5,9 +5,9 @@ license: PolyForm-Noncommercial-1.0.0 OR LicenseRef-PolyForm-Internal-Use-1.0.0
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned private fabric-agent-contract checkout. Works without those tools in an explicitly degraded structural-check mode. Ships in one plugin with adapting-projects-to-fabric, whose scripts it reuses.
 metadata:
   author: PassionCode.ai
-  version: "0.4.3"
+  version: "0.5.1"
   contract-version: "0.1.0"
-  contract-commit: "a5a27092ba0dcc5facfbeae8b359146dfb403e9a"
+  contract-commit: "9cd778eb6f14b977f9a5b4930826f62dc95c5619"
 ---
 
 # Creating Fabric-compatible agents
@@ -93,7 +93,7 @@ python3 <plugin-dir>/skills/adapting-projects-to-fabric/scripts/adapt_project.py
   --schema-base <immutable-base-uri>
 ```
 
-Pin exactly contract `0.1.0` at commit `a5a27092ba0dcc5facfbeae8b359146dfb403e9a` and
+Pin exactly contract `0.1.0` at commit `9cd778eb6f14b977f9a5b4930826f62dc95c5619` and
 read the pinned guide before implementing protocol details. If this skill is installed
 without its sibling, the scaffolder is absent: create the bundle by hand from the pinned
 contract's `docs/guides/connecting-compatible-agents.md` and mark the structural check
@@ -102,6 +102,12 @@ contract's `docs/guides/connecting-compatible-agents.md` and mark the structural
 The generated placeholders are deliberate blockers; a bundle still containing one is not
 ready for admission.
 
+A new agent is called the `fabric-interop/0.1` way from its first version: add `--job`
+for a capability whose work may outlive one request, serve each capability as the MCP
+tool of its name, and carry the caller's trace (the `building-fabric-services` interop
+reference). An agent that is not a service is announced with a provider entry
+(`adapting-projects-to-fabric`, `scripts/fabric_provider.py`).
+
 ## Step 4 — implement against the observables
 
 If the agent keeps running on the operator's computer — it answers other agents, runs

package/payload/plugins/passioncode/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "passioncode",
   "displayName": "PassionCode.ai",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "The organisation's working rules for every contributor's agent (working-in-passioncode), and a once-a-day check at session start that keeps the PassionCode.ai skill set current.",
   "author": {
     "name": "PassionCode.ai",