@zeroroot-ai/zerocool-claude 0.5.1 → 0.6.0

package/dist/tools/memory.js

@@ -1,96 +0,0 @@
-import { formatKnowledgeForPrompt, isSeamUnavailable, remember, WorldEntityKind } from "@zeroroot-ai/sdk";
-import { z } from "zod";
-import { failure, text } from "./result.js";
-/**
- * Memory and knowledge (gibson#1593, decisions 9 and 10).
- *
- * `remember` is `Observe(MemoryObservation)`: the memory lands in the tenant
- * World as a Timeline event and the projector writes the graph node. It exists
- * only in the live posture, because the World is written under a mission.
- *
- * `recall` reads the graph. In the live posture it reads as the task, in the
- * component posture as the component. The model decides when a lookup is worth
- * a round trip, and the query it writes beats anything derived from the prompt.
- */
-export function registerMemoryTools(server, g) {
-    if (g.knowledge) {
-        const knowledge = g.knowledge;
-        server.registerTool("recall", {
-            description: "Search this tenant's Gibson knowledge graph for memories, prior findings, targets and " +
-                "security facts recorded by earlier sessions and runs. Use it before you start on an " +
-                "unfamiliar area, or to check whether something was already recorded.",
-            inputSchema: {
-                query: z.string().describe("What to look for, in natural language."),
-                limit: z.number().int().min(1).max(50).optional().describe("Maximum hits. Defaults to 10."),
-                node_types: z
-                    .array(z.string())
-                    .optional()
-                    .describe('Restrict to node types, e.g. ["Observation"] for memories or ["Finding"].'),
-            },
-        }, async (args) => {
-            let hits;
-            try {
-                hits = await knowledge.query({
-                    text: args.query,
-                    topK: args.limit ?? 10,
-                    ...(args.node_types ? { nodeTypes: args.node_types } : {}),
-                });
-            }
-            catch (e) {
-                if (isSeamUnavailable(e)) {
-                    return text("recall unavailable", "The Gibson knowledge graph is not available on this daemon (gibson#1186). Continue without prior context.");
-                }
-                return failure("recall failed", e.message);
-            }
-            if (hits.length === 0)
-                return text("no matches", `Nothing in the tenant graph matches "${args.query}".`);
-            return text(`${hits.length} match${hits.length === 1 ? "" : "es"}`, formatKnowledgeForPrompt(hits));
-        });
-    }
-    if (g.live) {
-        const harness = g.live.harness;
-        server.registerTool("remember", {
-            description: "Keep a fact for later sessions, in this tenant's Gibson knowledge graph. Use it for a " +
-                "convention, a decision, a layout fact or a gotcha you would want back next time. Not for " +
-                "progress notes. A security finding goes to submit_finding instead.",
-            inputSchema: {
-                text: z.string().describe("The fact, in one or two sentences."),
-                kind: z.string().optional().describe('A short category: "convention", "decision", "layout", "gotcha".'),
-                tags: z.array(z.string()).optional().describe("Lower-case labels that help recall."),
-                source_ref: z.string().optional().describe("Where it came from: a path, a URL, or a work id."),
-            },
-        }, async (args) => {
-            try {
-                await remember(harness, { text: args.text, kind: args.kind, tags: args.tags, sourceRef: args.source_ref });
-            }
-            catch (e) {
-                return failure("remember failed", e.message);
-            }
-            return text("remembered", `Recorded in the tenant graph under mission ${g.live.missionId}.`);
-        });
-        server.registerTool("world_view", {
-            description: "Read this mission's slice of the tenant World: the hosts, domains, credentials, accounts " +
-                "and findings the platform knows about the target. Pass handles from a previous call in " +
-                "focus to zoom into entities.",
-            inputSchema: {
-                focus: z.array(z.string()).optional().describe("Entity handles from an earlier world_view call."),
-            },
-        }, async (args) => {
-            try {
-                const res = await harness.client.worldView({ context: harness.context, focus: args.focus ?? [] });
-                if (res.error)
-                    return failure("world_view refused", res.error.message);
-                if (res.entities.length === 0)
-                    return text("empty slice", "The World holds nothing for this target yet.");
-                const lines = res.entities.map((e) => {
-                    const attrs = Object.entries(e.attributes).map(([k, v]) => `${k}=${v}`).join(", ");
-                    return `- [${e.handle}] ${WorldEntityKind[e.kind] ?? e.kind} ${e.label}${attrs ? ` (${attrs})` : ""}`;
-                });
-                return text(`${res.entities.length} entit${res.entities.length === 1 ? "y" : "ies"}${res.truncated ? " (truncated)" : ""}`, lines.join("\n"));
-            }
-            catch (e) {
-                return failure("world_view failed", e.message);
-            }
-        });
-    }
-}

package/dist/tools/result.d.ts

@@ -1,5 +0,0 @@
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-/** One text block. MCP has no title/metadata split, so the title leads the text. */
-export declare function text(title: string, body: string, isError?: boolean): CallToolResult;
-/** Error text for a failure the model can act on. */
-export declare function failure(title: string, body: string): CallToolResult;

package/dist/tools/result.js

@@ -1,8 +0,0 @@
-/** One text block. MCP has no title/metadata split, so the title leads the text. */
-export function text(title, body, isError = false) {
-    return { content: [{ type: "text", text: title ? `${title}\n\n${body}` : body }], ...(isError ? { isError } : {}) };
-}
-/** Error text for a failure the model can act on. */
-export function failure(title, body) {
-    return text(title, body, true);
-}

package/dist/tools/status.d.ts

@@ -1,5 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { Gibson } from "../session.js";
-/** One tool that says what posture this session runs in and why. */
-export declare function registerStatusTool(server: McpServer, current: () => Gibson): void;
-export declare function describeGibson(g: Gibson): string;

package/dist/tools/status.js

@@ -1,21 +0,0 @@
-import { text } from "./result.js";
-/** One tool that says what posture this session runs in and why. */
-export function registerStatusTool(server, current) {
-    server.registerTool("gibson_status", { description: "Show how this session is connected to Gibson: standalone, component, or a live mission, and what is missing if anything.", inputSchema: {} }, async () => text("", describeGibson(current())));
-}
-export function describeGibson(g) {
-    const lines = [`posture: ${g.mode}`, `agent: ${g.agentName}`];
-    if (g.session)
-        lines.push(`component_scope: ${g.session.componentScope}`, `instance: ${g.session.instance.current()}`);
-    if (g.live) {
-        const exp = g.live.harness.expiresAt();
-        lines.push(`mission: ${g.live.missionId}`, `work: ${g.live.workId}`, `grant expires: ${exp ? new Date(exp).toISOString() : "unknown"}`);
-    }
-    if (g.settings.platformURL)
-        lines.push(`platform: ${g.settings.platformURL}`);
-    if (g.settings.targetId)
-        lines.push(`target: ${g.settings.targetId}`);
-    if (g.reason)
-        lines.push(`note: ${g.reason}`);
-    return lines.join("\n");
-}