umbrella-context 0.1.2

package/README.md

@@ -0,0 +1,41 @@
+# Umbrella Context CLI
+
+Use this CLI to connect a laptop or IDE to an Umbrella company context space.
+
+## Install
+
+```bash
+npm install -g umbrella-context
+```
+
+For local testing from a tarball:
+
+```bash
+npm install -g ./umbrella-context-0.1.1.tgz
+```
+
+## First-time setup
+
+```bash
+umbrella-context setup
+```
+
+The setup flow will:
+- connect to your Umbrella server
+- sign you in when needed
+- list your companies
+- let you choose a company
+- let you choose or create a context space
+- save this device config locally
+
+## Common commands
+
+```bash
+umbrella-context query "What do we already know?"
+umbrella-context curate "We learned that..."
+umbrella-context fix "ETIMEDOUT"
+umbrella-context mcp
+umbrella-context
+```
+
+The old `agent-memory` command still works as a compatibility alias.

package/dist/commands/connect.d.ts

@@ -0,0 +1 @@
+export declare function connectCommand(cli: any): void;

package/dist/commands/connect.js

@@ -0,0 +1,69 @@
+import chalk from "chalk";
+import { configManager } from "../config.js";
+import { ensureRepoContext } from "../repo-state.js";
+export function connectCommand(cli) {
+    cli
+        .command("connect", "Connect this device directly to a company context space without the interactive setup flow")
+        .option("--umbrella-url <url>", "Umbrella server URL for company and space metadata")
+        .option("--server-url <url>", "Agent Memory server URL")
+        .option("--company-id <id>", "Umbrella company ID")
+        .option("--company-name <name>", "Umbrella company name")
+        .option("--workspace-id <id>", "Underlying workspace ID")
+        .option("--workspace-name <name>", "Underlying workspace name")
+        .option("--space-id <id>", "Context space ID")
+        .option("--space-name <name>", "Context space name")
+        .option("--project-id <id>", "Deprecated alias for --space-id")
+        .option("--project-name <name>", "Deprecated alias for --space-name")
+        .option("--api-key <key>", "Context API key")
+        .action(async (options) => {
+        const serverUrl = options.serverUrl?.trim();
+        const workspaceId = options.workspaceId?.trim();
+        const workspaceName = options.workspaceName?.trim();
+        const companyId = options.companyId?.trim() ?? workspaceId;
+        const companyName = options.companyName?.trim() ?? workspaceName;
+        const projectId = options.spaceId?.trim() ?? options.projectId?.trim();
+        const projectName = options.spaceName?.trim() ?? options.projectName?.trim();
+        const apiKey = options.apiKey?.trim();
+        if (!serverUrl || !workspaceId || !workspaceName || !projectId || !projectName || !apiKey) {
+            console.log(chalk.red("\n Missing required connection details."));
+            return;
+        }
+        try {
+            const res = await fetch(`${serverUrl}/api/memories?limit=1`, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                },
+            });
+            if (!res.ok) {
+                const body = await res.text();
+                console.log(chalk.red(`\n Connection failed: ${body || res.statusText}`));
+                return;
+            }
+            configManager.set({
+                umbrellaUrl: options.umbrellaUrl?.trim(),
+                serverUrl,
+                companyId,
+                companyName,
+                workspaceId,
+                workspaceName,
+                projectId,
+                projectName,
+                apiKey,
+            });
+            configManager.upsertLocation({
+                repoRoot: process.cwd(),
+                companyId: companyId ?? workspaceId,
+                companyName: companyName ?? workspaceName,
+                projectId,
+                projectName,
+                updatedAt: new Date().toISOString(),
+            });
+            await ensureRepoContext(configManager.config);
+            console.log(chalk.green(`\n Connected: ${companyName} / ${projectName}`));
+            console.log(chalk.gray(` Config saved to ${configManager.configPath}`));
+        }
+        catch (err) {
+            console.log(chalk.red(`\n Error: ${err.message}`));
+        }
+    });
+}

package/dist/commands/curate.d.ts

@@ -0,0 +1,5 @@
+export declare function curateCommandAction(content: string, opts?: {
+    tag?: string | string[];
+    type?: string;
+}): Promise<void>;
+export declare function curateCommand(cli: any): void;

package/dist/commands/curate.js

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { configManager } from "../config.js";
+import { addPendingMemory, ensureRepoContext, getRepoContext } from "../repo-state.js";
+export async function curateCommandAction(content, opts = {}) {
+    const config = configManager.config;
+    if (!config) {
+        console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+        return;
+    }
+    if (!content?.trim()) {
+        console.log(chalk.red("\n Usage: umbrella-context curate \"What we learned\""));
+        return;
+    }
+    await ensureRepoContext(config);
+    const entry = await addPendingMemory({
+        content: content.trim(),
+        tags: opts.tag ? (Array.isArray(opts.tag) ? opts.tag : [opts.tag]) : [],
+        source: "cli",
+        systemType: opts.type || "system1_knowledge",
+    });
+    const { umDir } = await getRepoContext();
+    console.log(chalk.green(`\n Saved locally to ${config.companyName} / ${config.projectName}`));
+    console.log(chalk.gray(`   Pending entry: ${entry.id}`));
+    console.log(chalk.gray(`   Repo context folder: ${umDir}`));
+    console.log(chalk.gray('   Run "umbrella-context push" when you want to sync this to the server.'));
+}
+export function curateCommand(cli) {
+    cli
+        .command("curate <content>", "Save context locally in this repo so it can be pushed later")
+        .option("--tag <tag>", "Add tags (repeatable)")
+        .option("--type <type>", "system1_knowledge or system2_reasoning")
+        .action(async (content, opts) => {
+        await curateCommandAction(content, opts);
+    });
+}

package/dist/commands/fix.d.ts

@@ -0,0 +1 @@
+export declare function fixCommand(cli: any): void;

package/dist/commands/fix.js

@@ -0,0 +1,40 @@
+import chalk from "chalk";
+import { configManager } from "../config.js";
+export function fixCommand(cli) {
+    cli.command("fix <error>", "Search for known fixes to an error").action(async (error) => {
+        const config = configManager.config;
+        if (!config) {
+            console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+            return;
+        }
+        try {
+            const res = await fetch(`${config.serverUrl}/api/evolutions/search?error=${encodeURIComponent(error)}`, {
+                headers: { Authorization: `Bearer ${config.apiKey}` },
+            });
+            if (!res.ok) {
+                const err = await res.json();
+                console.log(chalk.red(`\n Failed: ${err.error}`));
+                return;
+            }
+            const data = await res.json();
+            if (data.results.length === 0) {
+                console.log(chalk.yellow(`\n No known fixes for "${error}"`));
+                return;
+            }
+            console.log(chalk.bold(`\n Found ${data.total} fixes for "${error}":\n`));
+            data.results.forEach((r, i) => {
+                const pct = Math.round(r.confidence * 100);
+                const color = pct >= 80 ? chalk.green : pct >= 60 ? chalk.yellow : chalk.red;
+                console.log(chalk.cyan(`  ${i + 1}.`));
+                console.log(`     Error: ${r.errorSignal}`);
+                console.log(`     Fix: ${r.solution}`);
+                console.log(color(`     Confidence: ${pct}% (${r.timesSucceeded}/${r.timesApplied} successes)`));
+                console.log(chalk.gray(`     Last applied: ${r.lastApplied ? new Date(r.lastApplied).toLocaleDateString() : "never"}`));
+                console.log("");
+            });
+        }
+        catch (err) {
+            console.log(chalk.red(`\n Error: ${err.message}`));
+        }
+    });
+}

package/dist/commands/interactive.d.ts

@@ -0,0 +1 @@
+export declare function interactiveCommand(_args: string[]): Promise<void>;

package/dist/commands/interactive.js

@@ -0,0 +1,145 @@
+import chalk from "chalk";
+import prompts from "prompts";
+import { configManager } from "../config.js";
+import { getCompanyContextSummary, toContextSpaces } from "../umbrella.js";
+import { curateCommandAction } from "./curate.js";
+import { pushCommandAction } from "./push.js";
+import { pullCommandAction } from "./pull.js";
+import { searchCommandAction } from "./search.js";
+import { statusCommandAction } from "./status.js";
+export async function interactiveCommand(_args) {
+    const config = configManager.config;
+    if (!config) {
+        console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+        return;
+    }
+    console.log(chalk.bold(`\n Umbrella Context - ${config.companyName} / ${config.projectName}\n`));
+    console.log(chalk.gray(" Commands: curate, query, push, pull, fix, record, spaces, status, exit\n"));
+    while (true) {
+        const input = await prompts({
+            type: "text",
+            name: "value",
+            message: ">",
+        });
+        if (!input.value)
+            continue;
+        const parts = input.value.trim().split(/\s+/);
+        const cmd = parts[0].toLowerCase();
+        const rest = parts.slice(1).join(" ");
+        if (cmd === "exit" || cmd === "quit")
+            break;
+        if (cmd === "curate") {
+            await curateCommandAction(rest);
+        }
+        else if (cmd === "push") {
+            await pushCommandAction();
+        }
+        else if (cmd === "pull") {
+            await pullCommandAction();
+        }
+        else if (cmd === "search" || cmd === "query") {
+            await searchCommandAction(rest);
+        }
+        else if (cmd === "fix") {
+            await handleFix(rest, config);
+        }
+        else if (cmd === "record") {
+            await handleRecord(parts.slice(1), config);
+        }
+        else if (cmd === "projects" || cmd === "spaces") {
+            await handleSpaces(config);
+        }
+        else if (cmd === "status") {
+            await statusCommandAction();
+        }
+        else if (cmd === "help") {
+            console.log(chalk.gray(`
+  curate <content>   Save a local context note into .um
+  query <query>      Search local and server context
+  push               Sync local .um notes to the server
+  pull               Refresh the local snapshot from the server
+  fix <error>        Search known fixes
+  record <id> <outcome>  Record success/failure
+  spaces             Show the current company and active space
+  status             Show current sync status
+  exit               Quit
+`));
+        }
+        else {
+            console.log(chalk.yellow(`Unknown command: ${cmd}. Type 'help' for commands.`));
+        }
+    }
+}
+async function handleFix(error, config) {
+    if (!error) {
+        console.log(chalk.red("Usage: fix <error>"));
+        return;
+    }
+    try {
+        const res = await fetch(`${config.serverUrl}/api/evolutions/search?error=${encodeURIComponent(error)}`, { headers: { Authorization: `Bearer ${config.apiKey}` } });
+        if (!res.ok)
+            return;
+        const data = await res.json();
+        if (data.results.length === 0) {
+            console.log(chalk.yellow("No known fixes"));
+            return;
+        }
+        data.results.forEach((result, index) => {
+            const pct = Math.round(result.confidence * 100);
+            console.log(chalk.cyan(`  ${index + 1}. [${pct}%]`));
+            console.log(`     ${result.solution}`);
+            console.log(chalk.gray(`     ${result.timesSucceeded}/${result.timesApplied} successes | ID: ${result.id}`));
+            console.log("");
+        });
+    }
+    catch (err) {
+        console.log(chalk.red(`Error: ${err.message}`));
+    }
+}
+async function handleRecord(parts, config) {
+    const [id, outcome] = parts;
+    if (!id || !["success", "failure"].includes(outcome)) {
+        console.log(chalk.red("Usage: record <id> <success|failure>"));
+        return;
+    }
+    try {
+        const res = await fetch(`${config.serverUrl}/api/evolutions/${id}/record-outcome`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${config.apiKey}`,
+            },
+            body: JSON.stringify({ outcome }),
+        });
+        if (!res.ok)
+            return;
+        const data = await res.json();
+        const pct = Math.round(data.confidence * 100);
+        console.log(chalk.green(`Recorded ${outcome} - confidence: ${pct}%`));
+    }
+    catch (err) {
+        console.log(chalk.red(`Error: ${err.message}`));
+    }
+}
+async function handleSpaces(config) {
+    console.log(chalk.cyan(`  Current company: ${config.companyName}`));
+    console.log(chalk.cyan(`  Current space: ${config.projectName}`));
+    if (!config.umbrellaUrl) {
+        console.log(chalk.gray("  Run setup again if you want this terminal to list all company spaces."));
+        return;
+    }
+    try {
+        const summary = await getCompanyContextSummary(config.umbrellaUrl, config.companyId);
+        const spaces = toContextSpaces(summary);
+        console.log("");
+        spaces.forEach((space, index) => {
+            const active = space.id === config.projectId ? " (active)" : "";
+            const core = space.isPrimary ? " [core]" : "";
+            console.log(chalk.gray(`  ${index + 1}. ${space.name}${core}${active}`));
+        });
+        console.log(chalk.gray('\n  To switch spaces, run "umbrella-context space switch".'));
+    }
+    catch (err) {
+        console.log(chalk.red(`  Could not load spaces: ${err.message}`));
+    }
+}

package/dist/commands/locations.d.ts

@@ -0,0 +1 @@
+export declare function locationsCommand(cli: any): void;

package/dist/commands/locations.js

@@ -0,0 +1,17 @@
+import chalk from "chalk";
+import { configManager } from "../config.js";
+export function locationsCommand(cli) {
+    cli.command("locations", "List repo folders that have been connected on this machine").action(() => {
+        const locations = configManager.locations;
+        if (locations.length === 0) {
+            console.log(chalk.yellow("\n No repo locations saved yet."));
+            return;
+        }
+        console.log(chalk.bold("\n Saved Context Locations\n"));
+        locations.forEach((location, index) => {
+            console.log(chalk.cyan(` ${index + 1}. ${location.companyName} / ${location.projectName}`));
+            console.log(chalk.gray(`    ${location.repoRoot}`));
+            console.log(chalk.gray(`    Updated: ${new Date(location.updatedAt).toLocaleString()}`));
+        });
+    });
+}

package/dist/commands/login.d.ts

@@ -0,0 +1 @@
+export declare function loginCommand(cli: any): void;

package/dist/commands/login.js

@@ -0,0 +1,7 @@
+import chalk from "chalk";
+export function loginCommand(cli) {
+    cli.command("login", "Alias for `umbrella-context setup`").action(async () => {
+        console.log(chalk.gray("`umbrella-context login` now uses the Umbrella setup flow."));
+        console.log(chalk.gray("Run `umbrella-context setup` to sign in, choose a company, and choose a context space."));
+    });
+}

package/dist/commands/mcp.d.ts

@@ -0,0 +1 @@
+export declare function mcpCommand(cli: any): void;

package/dist/commands/mcp.js

@@ -0,0 +1,73 @@
+import chalk from "chalk";
+import { configManager } from "../config.js";
+export function mcpCommand(cli) {
+    cli.command("mcp", "Run as MCP server for IDE integration (Cursor, Claude Code, etc.)").action(async () => {
+        const config = configManager.config;
+        if (!config) {
+            console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+            return;
+        }
+        console.log(chalk.green(`\n MCP server starting - connected to ${config.serverUrl}`));
+        console.log(chalk.gray(` Space: ${config.projectName}\n`));
+        try {
+            const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+            const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+            const { z } = await import("zod");
+            const server = new McpServer({
+                name: "umbrella-context",
+                version: "0.1.1",
+            });
+            server.tool("memory_search", "Search stored memories for company context knowledge", { query: z.string().describe("Search query"), limit: z.number().optional().default(10) }, async ({ query, limit }) => {
+                const res = await fetch(`${config.serverUrl}/api/memories/search?query=${encodeURIComponent(query)}&limit=${limit}`, { headers: { Authorization: `Bearer ${config.apiKey}` } });
+                const data = await res.json();
+                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+            });
+            server.tool("memory_push", "Save a memory or note to the current context space", { content: z.string().describe("The memory content"), tags: z.array(z.string()).optional() }, async ({ content, tags }) => {
+                const res = await fetch(`${config.serverUrl}/api/memories`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.apiKey}` },
+                    body: JSON.stringify({ content, tags: tags || [], source: "mcp" }),
+                });
+                const data = await res.json();
+                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+            });
+            server.tool("evolution_search", "Search for known fixes to an error signal", { error: z.string().describe("Error message or signal") }, async ({ error }) => {
+                const res = await fetch(`${config.serverUrl}/api/evolutions/search?error=${encodeURIComponent(error)}`, { headers: { Authorization: `Bearer ${config.apiKey}` } });
+                const data = await res.json();
+                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+            });
+            server.tool("evolution_push", "Record an error fix for future reference", {
+                errorSignal: z.string().describe("The error message"),
+                solution: z.string().describe("How it was fixed"),
+                outcome: z.enum(["success", "failure", "partial"]).optional().default("success"),
+            }, async ({ errorSignal, solution, outcome }) => {
+                const res = await fetch(`${config.serverUrl}/api/evolutions`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.apiKey}` },
+                    body: JSON.stringify({ errorSignal, solution, outcome }),
+                });
+                const data = await res.json();
+                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+            });
+            server.tool("record_outcome", "Record whether a previously applied fix worked", {
+                id: z.string().describe("Evolution ID"),
+                outcome: z.enum(["success", "failure"]).describe("Whether the fix worked"),
+            }, async ({ id, outcome }) => {
+                const res = await fetch(`${config.serverUrl}/api/evolutions/${id}/record-outcome`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.apiKey}` },
+                    body: JSON.stringify({ outcome }),
+                });
+                const data = await res.json();
+                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+            });
+            const transport = new StdioServerTransport();
+            await server.connect(transport);
+            console.error("MCP server running on stdio");
+        }
+        catch (err) {
+            console.log(chalk.red(`\n MCP server error: ${err.message}`));
+            console.log(chalk.gray("\n Make sure @modelcontextprotocol/sdk and zod are installed in the CLI package."));
+        }
+    });
+}

package/dist/commands/pull.d.ts

@@ -0,0 +1,2 @@
+export declare function pullCommandAction(): Promise<void>;
+export declare function pullCommand(cli: any): void;

package/dist/commands/pull.js

@@ -0,0 +1,58 @@
+import chalk from "chalk";
+import { configManager } from "../config.js";
+import { ensureRepoContext, setPulledFixes, setPulledMemories } from "../repo-state.js";
+export async function pullCommandAction() {
+    const config = configManager.config;
+    if (!config) {
+        console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+        return;
+    }
+    try {
+        await ensureRepoContext(config);
+        const [memoriesRes, fixesRes] = await Promise.all([
+            fetch(`${config.serverUrl}/api/memories?limit=50`, {
+                headers: { Authorization: `Bearer ${config.apiKey}` },
+            }),
+            fetch(`${config.serverUrl}/api/evolutions?limit=50`, {
+                headers: { Authorization: `Bearer ${config.apiKey}` },
+            }),
+        ]);
+        if (!memoriesRes.ok) {
+            const err = await memoriesRes.text();
+            console.log(chalk.red(`\n Pull failed: ${err || memoriesRes.statusText}`));
+            return;
+        }
+        const memoriesJson = await memoriesRes.json();
+        const fixesJson = fixesRes.ok ? await fixesRes.json() : { results: [] };
+        await setPulledMemories((memoriesJson.results ?? []).map((entry) => ({
+            id: entry.id,
+            content: entry.content,
+            tags: entry.tags ?? [],
+            source: entry.source ?? "server",
+            systemType: entry.systemType ?? "system1_knowledge",
+            createdAt: entry.createdAt ?? new Date().toISOString(),
+        })));
+        await setPulledFixes((fixesJson.results ?? []).map((entry) => ({
+            id: entry.id,
+            errorSignal: entry.errorSignal,
+            solution: entry.solution,
+            confidence: entry.confidence ?? 0,
+            timesApplied: entry.timesApplied ?? 0,
+            timesSucceeded: entry.timesSucceeded ?? 0,
+            createdAt: entry.createdAt ?? new Date().toISOString(),
+            lastApplied: entry.lastApplied ?? null,
+        })));
+        console.log(chalk.green(`\n Pulled ${memoriesJson.results?.length ?? 0} context entries from the server.`));
+        console.log(chalk.gray(`   Company: ${config.companyName}`));
+        console.log(chalk.gray(`   Space: ${config.projectName}`));
+        console.log(chalk.gray(`   Known fixes cached: ${fixesJson.results?.length ?? 0}`));
+    }
+    catch (err) {
+        console.log(chalk.red(`\n Error: ${err.message}`));
+    }
+}
+export function pullCommand(cli) {
+    cli.command("pull", "Refresh the local .um snapshot from the server").action(async () => {
+        await pullCommandAction();
+    });
+}

package/dist/commands/push.d.ts

@@ -0,0 +1,2 @@
+export declare function pushCommandAction(): Promise<void>;
+export declare function pushCommand(cli: any): void;

package/dist/commands/push.js

@@ -0,0 +1,65 @@
+import chalk from "chalk";
+import { configManager } from "../config.js";
+import { clearPendingMemories, ensureRepoContext, getPendingMemories, getPulledMemories, markPushCompleted, setPulledMemories, } from "../repo-state.js";
+export async function pushCommandAction() {
+    const config = configManager.config;
+    if (!config) {
+        console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+        return;
+    }
+    try {
+        await ensureRepoContext(config);
+        const pending = await getPendingMemories();
+        if (pending.length === 0) {
+            console.log(chalk.yellow("\n Nothing to push. Your local .um folder is already in sync."));
+            return;
+        }
+        const synced = [];
+        for (const entry of pending) {
+            const res = await fetch(`${config.serverUrl}/api/memories`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${config.apiKey}`,
+                },
+                body: JSON.stringify({
+                    content: entry.content,
+                    tags: entry.tags,
+                    source: entry.source,
+                    systemType: entry.systemType,
+                }),
+            });
+            if (!res.ok) {
+                const err = await res.text();
+                console.log(chalk.red(`\n Push failed: ${err || res.statusText}`));
+                return;
+            }
+            synced.push(await res.json());
+        }
+        const existingPulled = await getPulledMemories();
+        await setPulledMemories([
+            ...synced.map((entry) => ({
+                id: entry.id,
+                content: entry.content,
+                tags: entry.tags ?? [],
+                source: entry.source ?? "cli",
+                systemType: entry.systemType ?? "system1_knowledge",
+                createdAt: entry.createdAt ?? new Date().toISOString(),
+            })),
+            ...existingPulled,
+        ]);
+        await clearPendingMemories();
+        await markPushCompleted();
+        console.log(chalk.green(`\n Pushed ${synced.length} local context entr${synced.length === 1 ? "y" : "ies"}.`));
+        console.log(chalk.gray(`   Company: ${config.companyName}`));
+        console.log(chalk.gray(`   Space: ${config.projectName}`));
+    }
+    catch (err) {
+        console.log(chalk.red(`\n Error: ${err.message}`));
+    }
+}
+export function pushCommand(cli) {
+    cli.command("push", "Push pending local .um context to the server").action(async () => {
+        await pushCommandAction();
+    });
+}

package/dist/commands/record.d.ts

@@ -0,0 +1 @@
+export declare function recordCommand(cli: any): void;

package/dist/commands/record.js

@@ -0,0 +1,37 @@
+import chalk from "chalk";
+import { configManager } from "../config.js";
+export function recordCommand(cli) {
+    cli.command("record <id> <outcome>", "Record whether a fix worked or not").action(async (id, outcome) => {
+        const config = configManager.config;
+        if (!config) {
+            console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+            return;
+        }
+        if (!["success", "failure"].includes(outcome)) {
+            console.log(chalk.red("Outcome must be 'success' or 'failure'"));
+            return;
+        }
+        try {
+            const res = await fetch(`${config.serverUrl}/api/evolutions/${id}/record-outcome`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${config.apiKey}`,
+                },
+                body: JSON.stringify({ outcome }),
+            });
+            if (!res.ok) {
+                const err = await res.json();
+                console.log(chalk.red(`\n Failed: ${err.error}`));
+                return;
+            }
+            const data = await res.json();
+            const pct = Math.round(data.confidence * 100);
+            console.log(chalk.green(`\n Recorded ${outcome}`));
+            console.log(`   New confidence: ${pct}% (${data.timesSucceeded}/${data.timesApplied})`);
+        }
+        catch (err) {
+            console.log(chalk.red(`\n Error: ${err.message}`));
+        }
+    });
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,2 @@
+export declare function searchCommandAction(query: string): Promise<void>;
+export declare function searchCommand(cli: any): void;