@anna-ai/cli 0.1.12 → 0.1.16

package/templates/executa/python/__SLUG_PY___plugin.py

@@ -0,0 +1,146 @@
+"""Minimal stdio Executa plugin scaffold (Python).
+
+Speaks Executa JSON-RPC 2.0 over stdin/stdout. Implements both v1
+methods (`describe`, `health`, `invoke`) and the v2 `initialize`
+handshake so a host that knows sampling can attach reverse-RPC support.
+
+Run locally:
+
+    anna-app executa dev --describe
+    anna-app executa dev --invoke ping
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import uuid
+from typing import Any
+
+MANIFEST: dict[str, Any] = {
+    "name": "__TOOL_ID__",
+    "display_name": "__TOOL_ID__",
+    "version": "0.1.0",
+    "description": "A minimal Executa plugin scaffold.",
+    # Declaring `host_capabilities` here is informational for the
+    # registry; `client_capabilities.sampling` in the initialize
+    # response is what actually unlocks reverse-RPC sampling.
+    "host_capabilities": ["llm.sample"],
+    "tools": [
+        {
+            "name": "ping",
+            "description": "Smoke-test method.",
+            "parameters": [],
+        },
+        {
+            "name": "summarize",
+            "description": "Summarize a piece of text via host sampling.",
+            "parameters": [
+                {
+                    "name": "text",
+                    "type": "string",
+                    "description": "Text to summarize.",
+                    "required": True,
+                }
+            ],
+        },
+    ],
+}
+
+# Track in-flight reverse-RPC requests we initiate to the host.
+_PENDING: dict[str, Any] = {}
+
+
+def _write(envelope: dict[str, Any]) -> None:
+    sys.stdout.write(json.dumps(envelope) + "\n")
+    sys.stdout.flush()
+
+
+def _request_sampling(prompt: str) -> dict[str, Any]:
+    """Issue a reverse-RPC `sampling/createMessage` and block until response."""
+    rid = str(uuid.uuid4())
+    _write(
+        {
+            "jsonrpc": "2.0",
+            "id": rid,
+            "method": "sampling/createMessage",
+            "params": {
+                "messages": [
+                    {"role": "user", "content": {"type": "text", "text": prompt}}
+                ],
+                "maxTokens": 400,
+            },
+        }
+    )
+    # Loop on stdin until our response arrives. Anything that's not the
+    # expected response is dispatched normally.
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        env = json.loads(line)
+        if env.get("id") == rid and "method" not in env:
+            if "error" in env:
+                raise RuntimeError(env["error"].get("message", "sampling failed"))
+            return env.get("result", {})
+        # Re-queue other requests by handling them inline.
+        _dispatch(env)
+    raise RuntimeError("stdin closed before sampling response arrived")
+
+
+def invoke(method: str, args: dict[str, Any]) -> dict[str, Any]:
+    if method == "ping":
+        return {"success": True, "data": {"pong": True}}
+    if method == "summarize":
+        text = args.get("text", "")
+        if not text:
+            return {"success": False, "error": "text is required"}
+        try:
+            sample = _request_sampling(f"Summarize in one sentence:\n{text}")
+            summary = sample.get("content", {}).get("text", "")
+            return {"success": True, "data": {"summary": summary}}
+        except Exception as e:  # noqa: BLE001
+            return {"success": False, "error": f"sampling failed: {e}"}
+    return {"success": False, "error": f"unknown method: {method}"}
+
+
+def _dispatch(env: dict[str, Any]) -> None:
+    method = env.get("method")
+    rid = env.get("id")
+    try:
+        if method == "initialize":
+            result = {
+                "protocolVersion": "2.0",
+                "server_info": {"name": MANIFEST["name"], "version": MANIFEST["version"]},
+                "capabilities": {"sampling": {}},
+            }
+        elif method == "describe":
+            result = MANIFEST
+        elif method == "health":
+            result = {"status": "ok"}
+        elif method == "invoke":
+            params = env.get("params", {})
+            result = invoke(params.get("tool", ""), params.get("arguments", {}))
+        else:
+            raise ValueError(f"unknown rpc: {method}")
+        _write({"jsonrpc": "2.0", "id": rid, "result": result})
+    except Exception as e:  # noqa: BLE001
+        _write(
+            {
+                "jsonrpc": "2.0",
+                "id": rid,
+                "error": {"code": -32601, "message": str(e)},
+            }
+        )
+
+
+def main() -> None:
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        _dispatch(json.loads(line))
+
+
+if __name__ == "__main__":
+    main()

package/templates/executa/python/executa.json

@@ -0,0 +1,4 @@
+{
+  "tool_id": "__TOOL_ID__",
+  "type": "python"
+}

package/templates/executa/python/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "__TOOL_ID__"
+version = "0.1.0"
+description = "Executa plugin: __SLUG__"
+requires-python = ">=3.10"
+
+[project.scripts]
+"__TOOL_ID__" = "__SLUG_PY___plugin:main"
+
+[tool.setuptools]
+py-modules = ["__SLUG_PY___plugin"]

package/templates/executa/python/sampling-fixture.jsonl

@@ -0,0 +1,4 @@
+# Sampling fixture for `anna-app executa dev --mock-sampling`.
+# One JSON object per line. Match the first entry whose `ns`+`method`
+# (and optional content substring) matches the reverse-RPC.
+{"ns":"sampling","method":"createMessage","result":{"role":"assistant","content":{"type":"text","text":"(mock) a one-line summary"},"model":"mock-model","stopReason":"endTurn"}}

package/templates/minimal/bundle/app.js

@@ -1,4 +1,6 @@
 // Minimal Anna App bundle entry. Replace with real logic.
+import { AnnaAppRuntime } from "/static/anna-apps/_sdk/latest/index.js";
+
 const TOOL_ID = "__TOOL_ID__";
 
 async function main() {

package/templates/minimal/bundle/index.html

@@ -3,8 +3,7 @@
   <head>
     <meta charset="utf-8" />
     <title>__SLUG__</title>
-    <script src="/static/anna-apps/_sdk/0.1.0/index.js" defer></script>
-    <script src="./app.js" defer></script>
+    <script src="./app.js" type="module"></script>
   </head>
   <body>
     <h1>__SLUG__</h1>

package/dist/bridge-BEHyfpPI.js

@@ -1,3 +0,0 @@
-import { PINNED_RUNTIME_VERSION, PythonBridge } from "./bridge-BQUo6ehX.js";
-
-export { PINNED_RUNTIME_VERSION, PythonBridge };

package/dist/dev-app-cache-BMfOlTHd.js

@@ -1,93 +0,0 @@
-import { canonicalHost } from "./credentials-BTv2IfUZ.js";
-import { dirname, join, resolve } from "node:path";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-
-//#region src/dev-app-cache.ts
-const CACHE_DIR = ".anna";
-const CACHE_FILE = "dev-app.json";
-function cachePath(cwd) {
-	return resolve(cwd, CACHE_DIR, CACHE_FILE);
-}
-function readDevAppCache(cwd) {
-	const p = cachePath(cwd);
-	if (!existsSync(p)) return null;
-	try {
-		const raw = JSON.parse(readFileSync(p, "utf-8"));
-		if (typeof raw.host === "string" && typeof raw.slug === "string" && typeof raw.app_id === "number") return {
-			host: raw.host,
-			slug: raw.slug,
-			app_id: raw.app_id,
-			name: raw.name ?? raw.slug,
-			registered_at: raw.registered_at ?? ""
-		};
-	} catch {}
-	return null;
-}
-function writeDevAppCache(cwd, entry) {
-	const p = cachePath(cwd);
-	mkdirSync(dirname(p), { recursive: true });
-	writeFileSync(p, JSON.stringify(entry, null, 2) + "\n", "utf-8");
-}
-/** Call POST /api/v1/anna-apps/dev/apps/register. Idempotent server-side. */
-async function registerDevApp(args) {
-	const url = `${canonicalHost(args.host)}/api/v1/anna-apps/dev/apps/register`;
-	const res = await fetch(url, {
-		method: "POST",
-		headers: { "content-type": "application/json" },
-		body: JSON.stringify({
-			pat: args.pat,
-			slug: args.input.slug,
-			name: args.input.name,
-			category: args.input.category,
-			tagline: args.input.tagline
-		})
-	});
-	if (!res.ok) {
-		const text = await res.text().catch(() => "");
-		throw new Error(`/dev/apps/register failed: HTTP ${res.status} ${text}`);
-	}
-	return await res.json();
-}
-/** Call GET /api/v1/anna-apps/dev/apps. */
-async function listDevApps(args) {
-	const url = new URL(`${canonicalHost(args.host)}/api/v1/anna-apps/dev/apps`);
-	url.searchParams.set("pat", args.pat);
-	const res = await fetch(url, { method: "GET" });
-	if (!res.ok) {
-		const text = await res.text().catch(() => "");
-		throw new Error(`/dev/apps failed: HTTP ${res.status} ${text}`);
-	}
-	const body = await res.json();
-	return body.apps;
-}
-/**
-* Convenience helper for `anna-app dev`: returns a valid cached entry if
-* it still matches the manifest slug, otherwise hits the server to
-* (re-)register. Throws if no PAT is available on disk.
-*/
-async function ensureDevAppRegistered(args) {
-	const canonical = canonicalHost(args.host);
-	const cached = readDevAppCache(args.cwd);
-	if (cached && cached.host === canonical && cached.slug === args.input.slug) return cached;
-	const r = await registerDevApp({
-		host: args.host,
-		pat: args.pat,
-		input: args.input
-	});
-	const entry = {
-		host: canonical,
-		slug: r.slug,
-		app_id: r.app_id,
-		name: r.name,
-		registered_at: new Date().toISOString()
-	};
-	writeDevAppCache(args.cwd, entry);
-	return entry;
-}
-const _internal = {
-	cachePath,
-	CACHE_DIR: join(CACHE_DIR, CACHE_FILE)
-};
-
-//#endregion
-export { ensureDevAppRegistered, listDevApps, readDevAppCache, registerDevApp, writeDevAppCache };

package/dist/dev-app-cache-cXvO2XwQ.js

@@ -1,4 +0,0 @@
-import "./credentials-BTv2IfUZ.js";
-import { ensureDevAppRegistered, listDevApps, readDevAppCache, registerDevApp, writeDevAppCache } from "./dev-app-cache-BMfOlTHd.js";
-
-export { ensureDevAppRegistered };