@apolloyh/apollo-agent 0.1.0

package/dist/llm/anthropic.d.ts

@@ -0,0 +1,46 @@
+import type { AnthropicTool, ContentBlock, LlmConfig, Message } from "../types.js";
+export type AnthropicResponse = {
+    id: string;
+    type: string;
+    role: "assistant";
+    content: ContentBlock[];
+    stop_reason?: string;
+    usage?: AnthropicUsage;
+};
+export type AnthropicUsage = {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens: number;
+    cache_read_input_tokens: number;
+};
+export type ToolInputDelta = {
+    bytes: number;
+    tool?: string;
+    detail?: string;
+};
+export declare class MalformedStreamError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+export declare class MalformedToolInputError extends MalformedStreamError {
+    constructor(tool: string, bytes: number, cause: unknown);
+}
+export declare class AnthropicApiError extends Error {
+    readonly status: number;
+    readonly responseBody: string;
+    readonly responseHeaders: Headers;
+    constructor(status: number, responseBody: string, responseHeaders: Headers);
+}
+export declare class AnthropicClient {
+    private readonly config;
+    constructor(config: LlmConfig);
+    createMessage(input: {
+        system: string;
+        messages: Message[];
+        tools: AnthropicTool[];
+        stream?: boolean;
+        signal?: AbortSignal;
+        onTextDelta?: (text: string) => void;
+        onToolInputDelta?: (event: ToolInputDelta) => void;
+    }): Promise<AnthropicResponse>;
+}
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/llm/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../src/llm/anthropic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEnF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,2BAA2B,EAAE,MAAM,CAAC;IACpC,uBAAuB,EAAE,MAAM,CAAC;CACjC,CAAC;AAMF,MAAM,MAAM,cAAc,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/E,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;CAI7C;AAED,qBAAa,uBAAwB,SAAQ,oBAAoB;gBACnD,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;CAIxD;AAED,qBAAa,iBAAkB,SAAQ,KAAK;aAExB,MAAM,EAAE,MAAM;aACd,YAAY,EAAE,MAAM;aACpB,eAAe,EAAE,OAAO;gBAFxB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,eAAe,EAAE,OAAO;CAK3C;AAED,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS;IAExC,aAAa,CAAC,KAAK,EAAE;QACzB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,OAAO,EAAE,CAAC;QACpB,KAAK,EAAE,aAAa,EAAE,CAAC;QACvB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;QACrC,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;KACpD,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAqC/B"}

package/dist/llm/anthropic.js

@@ -0,0 +1,278 @@
+export class MalformedStreamError extends Error {
+    constructor(message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "MalformedStreamError";
+    }
+}
+export class MalformedToolInputError extends MalformedStreamError {
+    constructor(tool, bytes, cause) {
+        super(`Model returned incomplete JSON for tool ${tool || "unknown"} (${bytes} characters).`, cause);
+        this.name = "MalformedToolInputError";
+    }
+}
+export class AnthropicApiError extends Error {
+    status;
+    responseBody;
+    responseHeaders;
+    constructor(status, responseBody, responseHeaders) {
+        super(`Anthropic API error ${status}: ${responseBody}`);
+        this.status = status;
+        this.responseBody = responseBody;
+        this.responseHeaders = responseHeaders;
+        this.name = "AnthropicApiError";
+    }
+}
+export class AnthropicClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async createMessage(input) {
+        const url = `${this.config.baseUrl.replace(/\/$/, "")}/v1/messages`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "anthropic-version": "2023-06-01",
+                "x-api-key": this.config.authToken,
+                authorization: `Bearer ${this.config.authToken}`,
+            },
+            body: JSON.stringify({
+                model: this.config.model,
+                max_tokens: this.config.maxTokens,
+                system: input.system,
+                messages: input.messages,
+                ...(input.tools.length > 0
+                    ? { tools: input.tools, tool_choice: { type: "auto" } }
+                    : {}),
+                cache_control: this.config.cacheTtl === "1h"
+                    ? { type: "ephemeral", ttl: "1h" }
+                    : { type: "ephemeral" },
+                stream: input.stream ?? false,
+            }),
+            signal: input.signal
+                ? AbortSignal.any([input.signal, AbortSignal.timeout(normalizeTimeout(this.config.timeoutMs))])
+                : AbortSignal.timeout(normalizeTimeout(this.config.timeoutMs)),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new AnthropicApiError(response.status, errorText, response.headers);
+        }
+        if (input.stream) {
+            return readStreamingResponse(response, input.onTextDelta, input.onToolInputDelta);
+        }
+        return (await response.json());
+    }
+}
+async function readStreamingResponse(response, onTextDelta, onToolInputDelta) {
+    if (!response.body)
+        throw new Error("Anthropic API returned an empty stream body.");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const blocks = new Map();
+    let buffer = "";
+    let responseId = "";
+    let stopReason;
+    let usage;
+    let streamEnded = false;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                streamEnded = true;
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let separator = buffer.match(/\r?\n\r?\n/);
+            while (separator?.index !== undefined) {
+                const separatorIndex = separator.index;
+                const rawEvent = buffer.slice(0, separatorIndex);
+                buffer = buffer.slice(separatorIndex + separator[0].length);
+                const data = parseSseData(rawEvent);
+                if (data && data !== "[DONE]") {
+                    const event = parseStreamEvent(data);
+                    if (event.type === "error") {
+                        throw new Error(`Anthropic stream error: ${JSON.stringify(event.error ?? event)}`);
+                    }
+                    applyStreamEvent(event, blocks, (id) => {
+                        responseId = id;
+                    }, (reason) => {
+                        stopReason = reason;
+                    }, (part) => {
+                        usage = mergeUsage(usage, part);
+                    }, onTextDelta, onToolInputDelta);
+                }
+                separator = buffer.match(/\r?\n\r?\n/);
+            }
+        }
+        buffer += decoder.decode();
+        if (buffer.trim()) {
+            const data = parseSseData(buffer);
+            if (data && data !== "[DONE]") {
+                const event = parseStreamEvent(data);
+                if (event.type === "error") {
+                    throw new Error(`Anthropic stream error: ${JSON.stringify(event.error ?? event)}`);
+                }
+                applyStreamEvent(event, blocks, (id) => {
+                    responseId = id;
+                }, (reason) => {
+                    stopReason = reason;
+                }, (part) => {
+                    usage = mergeUsage(usage, part);
+                }, onTextDelta, onToolInputDelta);
+            }
+        }
+        if (blocks.size === 0) {
+            throw new MalformedStreamError("Model returned an empty or incomplete event stream.");
+        }
+        return {
+            id: responseId,
+            type: "message",
+            role: "assistant",
+            content: Array.from(blocks.entries())
+                .sort(([left], [right]) => left - right)
+                .map(([, block]) => finalizeStreamBlock(block)),
+            stop_reason: stopReason,
+            usage,
+        };
+    }
+    finally {
+        if (!streamEnded)
+            await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
+function normalizeTimeout(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 300000;
+}
+function parseSseData(rawEvent) {
+    return rawEvent
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice("data:".length).trimStart())
+        .join("\n")
+        .trim();
+}
+function parseStreamEvent(data) {
+    try {
+        return JSON.parse(data);
+    }
+    catch (error) {
+        throw new MalformedStreamError("Model returned malformed JSON in the event stream.", error);
+    }
+}
+function applyStreamEvent(event, blocks, setResponseId, setStopReason, setUsage, onTextDelta, onToolInputDelta) {
+    if (event.type === "message_start") {
+        const message = event.message;
+        if (message?.id)
+            setResponseId(message.id);
+        if (message?.usage)
+            setUsage(message.usage);
+        return;
+    }
+    if (event.type === "message_delta") {
+        const delta = event.delta;
+        if (delta?.stop_reason)
+            setStopReason(delta.stop_reason);
+        if (event.usage)
+            setUsage(event.usage);
+        return;
+    }
+    if (event.type === "content_block_start") {
+        const index = Number(event.index);
+        const contentBlock = event.content_block;
+        if (!Number.isFinite(index) || !contentBlock)
+            return;
+        if (contentBlock.type === "text") {
+            blocks.set(index, { type: "text", text: contentBlock.text ?? "" });
+        }
+        else if (contentBlock.type === "tool_use") {
+            const block = {
+                type: "tool_use",
+                id: contentBlock.id ?? "",
+                name: contentBlock.name ?? "",
+                inputJson: "",
+            };
+            blocks.set(index, block);
+            onToolInputDelta?.({ bytes: 0, tool: block.name || undefined });
+        }
+        return;
+    }
+    if (event.type !== "content_block_delta")
+        return;
+    const index = Number(event.index);
+    const block = blocks.get(index);
+    const delta = event.delta;
+    if (!block || !delta)
+        return;
+    if (block.type === "text" && delta.type === "text_delta" && delta.text) {
+        block.text += delta.text;
+        onTextDelta?.(delta.text);
+    }
+    else if (block.type === "tool_use" && delta.type === "input_json_delta" && delta.partial_json) {
+        block.inputJson += delta.partial_json;
+        block.detail ??= partialToolDetail(block.inputJson);
+        onToolInputDelta?.({
+            bytes: block.inputJson.length,
+            tool: block.name || undefined,
+            detail: block.detail,
+        });
+    }
+}
+function partialToolDetail(inputJson) {
+    const match = inputJson
+        .slice(0, 8192)
+        .match(/"(?:path|file_path|command|query|url|description)"\s*:\s*"((?:\\.|[^"\\])*)"/);
+    if (!match?.[1])
+        return undefined;
+    try {
+        return JSON.parse(`"${match[1]}"`);
+    }
+    catch {
+        return undefined;
+    }
+}
+function mergeUsage(current, part) {
+    if (!part || typeof part !== "object")
+        return current;
+    const source = part;
+    const fields = [
+        "input_tokens",
+        "output_tokens",
+        "cache_creation_input_tokens",
+        "cache_read_input_tokens",
+    ];
+    if (!fields.some((field) => typeof source[field] === "number"))
+        return current;
+    const next = current ?? {
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0,
+    };
+    return fields.reduce((result, field) => {
+        const value = source[field];
+        if (typeof value === "number" && Number.isFinite(value))
+            result[field] = value;
+        return result;
+    }, { ...next });
+}
+function finalizeStreamBlock(block) {
+    if (block.type === "text")
+        return block;
+    let input = {};
+    if (block.inputJson.trim()) {
+        try {
+            input = JSON.parse(block.inputJson);
+        }
+        catch (error) {
+            throw new MalformedToolInputError(block.name, block.inputJson.length, error);
+        }
+    }
+    return {
+        type: "tool_use",
+        id: block.id,
+        name: block.name,
+        input,
+    };
+}

package/dist/mcp/manager.d.ts

@@ -0,0 +1,14 @@
+import type { AgentConfig, JsonObject } from "../types.js";
+export declare class McpManager {
+    private readonly config;
+    private readonly connections;
+    private readonly pending;
+    constructor(config: AgentConfig);
+    serverNames(): string[];
+    listTools(serverName?: string): Promise<unknown>;
+    callTool(serverName: string, toolName: string, args: JsonObject): Promise<string>;
+    closeAll(): Promise<void>;
+    private client;
+    private toTransportConfig;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/mcp/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/mcp/manager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAmB,MAAM,aAAa,CAAC;AAQ5E,qBAAa,UAAU;IAIT,OAAO,CAAC,QAAQ,CAAC,MAAM;IAHnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoC;IAChE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;gBAEjC,MAAM,EAAE,WAAW;IAEhD,WAAW,IAAI,MAAM,EAAE;IAIjB,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAahD,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAMjF,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;YAgBjB,MAAM;IA+BpB,OAAO,CAAC,iBAAiB;CAS1B"}

package/dist/mcp/manager.js

@@ -0,0 +1,93 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { stringify } from "../utils.js";
+export class McpManager {
+    config;
+    connections = new Map();
+    pending = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    serverNames() {
+        return Object.keys(this.config.mcpServers);
+    }
+    async listTools(serverName) {
+        if (serverName) {
+            const client = await this.client(serverName);
+            return { server: serverName, ...(await client.listTools()) };
+        }
+        const all = [];
+        for (const name of this.serverNames()) {
+            const client = await this.client(name);
+            all.push({ server: name, ...(await client.listTools()) });
+        }
+        return all;
+    }
+    async callTool(serverName, toolName, args) {
+        const client = await this.client(serverName);
+        const result = await client.callTool({ name: toolName, arguments: args });
+        return stringify(result, 12000);
+    }
+    async closeAll() {
+        // Wait for any in-flight connects to settle first, so a connection that finishes
+        // mid-close still lands in `connections` and gets reaped instead of leaking its child.
+        if (this.pending.size)
+            await Promise.allSettled(this.pending.values());
+        const failures = [];
+        for (const [name, { transport }] of this.connections) {
+            try {
+                await transport.close();
+                this.connections.delete(name);
+            }
+            catch (error) {
+                failures.push(error);
+            }
+        }
+        if (failures.length)
+            throw new AggregateError(failures, "Failed to close one or more MCP transports.");
+    }
+    async client(name) {
+        const existing = this.connections.get(name);
+        if (existing)
+            return existing.client;
+        // Cache the in-flight connect so concurrent callers share one child process
+        // instead of each spawning (and leaking) their own.
+        const inFlight = this.pending.get(name);
+        if (inFlight)
+            return inFlight;
+        const server = this.config.mcpServers[name];
+        if (!server)
+            throw new Error(`Unknown MCP server: ${name}`);
+        const connect = (async () => {
+            const transport = new StdioClientTransport(this.toTransportConfig(server));
+            const client = new Client({ name: "langcore-agent", version: "0.1.0" }, { capabilities: {} });
+            try {
+                await client.connect(transport);
+            }
+            catch (error) {
+                await transport.close().catch(() => undefined);
+                throw error;
+            }
+            // Drain stderr so a chatty server can't fill the pipe buffer and hang on write.
+            transport.stderr?.resume();
+            this.connections.set(name, { client, transport });
+            return client;
+        })();
+        this.pending.set(name, connect);
+        try {
+            return await connect;
+        }
+        finally {
+            this.pending.delete(name);
+        }
+    }
+    toTransportConfig(server) {
+        return {
+            command: server.command,
+            args: server.args,
+            env: server.env,
+            cwd: server.cwd,
+            stderr: "pipe",
+        };
+    }
+}

package/dist/memory/memdir.d.ts

@@ -0,0 +1,19 @@
+export type MemoryNote = {
+    id: string;
+    title: string;
+    content: string;
+    tags: string[];
+    createdAt: string;
+    updatedAt: string;
+};
+export declare function ensureMemoryDir(workspaceRoot: string): Promise<string>;
+export declare function listMemories(workspaceRoot: string): Promise<MemoryNote[]>;
+export declare function saveMemory(workspaceRoot: string, input: {
+    title: string;
+    content: string;
+    tags?: string[];
+    id?: string;
+}): Promise<MemoryNote>;
+export declare function searchMemories(workspaceRoot: string, query: string, limit?: number): Promise<MemoryNote[]>;
+export declare function memoryContextBlock(workspaceRoot: string, query: string, limit?: number): Promise<string>;
+//# sourceMappingURL=memdir.d.ts.map

package/dist/memory/memdir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memdir.d.ts","sourceRoot":"","sources":["../../src/memory/memdir.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAMF,wBAAsB,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAI5E;AAED,wBAAsB,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAmB/E;AAED,wBAAsB,UAAU,CAC9B,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,GACtE,OAAO,CAAC,UAAU,CAAC,CAuBrB;AAED,wBAAsB,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAiB3G;AAED,wBAAsB,kBAAkB,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAOzG"}

package/dist/memory/memdir.js

@@ -0,0 +1,96 @@
+/**
+ * Memory directory (CC memdir-inspired).
+ * Stores short durable notes under .apollo/memory/
+ */
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { safeRealResolve } from "../utils.js";
+import { writeFileAtomic } from "../session/store.js";
+function memoryDir(workspaceRoot) {
+    return path.join(workspaceRoot, ".apollo", "memory");
+}
+export async function ensureMemoryDir(workspaceRoot) {
+    const dir = await safeRealResolve(workspaceRoot, memoryDir(workspaceRoot));
+    await fs.mkdir(dir, { recursive: true });
+    return dir;
+}
+export async function listMemories(workspaceRoot) {
+    const dir = await ensureMemoryDir(workspaceRoot);
+    let names = [];
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const notes = [];
+    for (const name of names) {
+        if (!name.endsWith(".json"))
+            continue;
+        try {
+            const raw = await fs.readFile(await safeRealResolve(dir, path.join(dir, name)), "utf8");
+            notes.push(JSON.parse(raw));
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return notes.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+export async function saveMemory(workspaceRoot, input) {
+    const dir = await ensureMemoryDir(workspaceRoot);
+    const now = new Date().toISOString();
+    const id = input.id ?? `m-${randomUUID()}`;
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(id))
+        throw new Error(`Invalid memory id: ${id}`);
+    const file = await safeRealResolve(dir, path.join(dir, `${id}.json`));
+    const note = {
+        id,
+        title: input.title.slice(0, 120),
+        content: input.content.slice(0, 20000),
+        tags: input.tags ?? [],
+        createdAt: now,
+        updatedAt: now,
+    };
+    // preserve createdAt if updating
+    try {
+        const existing = JSON.parse(await fs.readFile(file, "utf8"));
+        note.createdAt = existing.createdAt;
+    }
+    catch {
+        /* new */
+    }
+    await writeFileAtomic(file, JSON.stringify(note, null, 2));
+    return note;
+}
+export async function searchMemories(workspaceRoot, query, limit = 8) {
+    const q = query.toLowerCase().trim();
+    const all = await listMemories(workspaceRoot);
+    if (!q)
+        return all.slice(0, limit);
+    const scored = all
+        .map((n) => {
+        const hay = `${n.title}\n${n.content}\n${n.tags.join(" ")}`.toLowerCase();
+        let score = 0;
+        for (const term of q.split(/\s+/)) {
+            if (hay.includes(term))
+                score += 1;
+            if (n.title.toLowerCase().includes(term))
+                score += 2;
+        }
+        return { n, score };
+    })
+        .filter((x) => x.score > 0)
+        .sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit).map((x) => x.n);
+}
+export async function memoryContextBlock(workspaceRoot, query, limit = 5) {
+    const hits = await searchMemories(workspaceRoot, query, limit);
+    if (!hits.length)
+        return "";
+    const body = hits
+        .map((n) => `### ${n.title}\n${n.content.slice(0, 1500)}`)
+        .join("\n\n");
+    return `# Relevant Memories\nThe following notes were retrieved from the project memory store. Use when relevant.\n\n${body}`;
+}

package/dist/plan/plan-mode.d.ts

@@ -0,0 +1,14 @@
+export type PlanState = {
+    active: boolean;
+    path: string;
+    content: string;
+    approved: boolean;
+    createdAt: string;
+};
+export declare function planFilePath(workspaceRoot: string): string;
+export declare function writePlan(workspaceRoot: string, content: string): Promise<PlanState>;
+export declare function readPlan(workspaceRoot: string): Promise<PlanState | null>;
+export declare function planModeSystemExtra(plan: PlanState | null, mode: "plan" | "normal"): string;
+/** Read-only tools permitted in plan mode. Everything else is denied by default. */
+export declare function isPlanModeToolAllowed(toolName: string, input: Record<string, unknown>, workspaceRoot: string): boolean;
+//# sourceMappingURL=plan-mode.d.ts.map

package/dist/plan/plan-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-mode.d.ts","sourceRoot":"","sources":["../../src/plan/plan-mode.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAsB,SAAS,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAY1F;AAED,wBAAsB,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAc/E;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,CA4B3F;AAED,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAsBtH"}

package/dist/plan/plan-mode.js

@@ -0,0 +1,90 @@
+/**
+ * Plan mode — plan → user confirm → execute (CC EnterPlanMode / ExitPlanMode inspired).
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { safeRealResolve } from "../utils.js";
+export function planFilePath(workspaceRoot) {
+    return path.join(workspaceRoot, ".apollo", "plan.md");
+}
+export async function writePlan(workspaceRoot, content) {
+    const file = await safeRealResolve(workspaceRoot, planFilePath(workspaceRoot));
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const body = content.trim() || "# Plan\n\n(empty)\n";
+    await fs.writeFile(file, body, "utf8");
+    return {
+        active: true,
+        path: file,
+        content: body,
+        approved: false,
+        createdAt: new Date().toISOString(),
+    };
+}
+export async function readPlan(workspaceRoot) {
+    try {
+        const file = await safeRealResolve(workspaceRoot, planFilePath(workspaceRoot));
+        const content = await fs.readFile(file, "utf8");
+        return {
+            active: true,
+            path: file,
+            content,
+            approved: false,
+            createdAt: "",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function planModeSystemExtra(plan, mode) {
+    if (mode !== "plan") {
+        if (plan?.approved) {
+            return `# Plan Execution
+A plan was approved. Implement it carefully. Plan file: ${plan.path}
+
+## Approved Plan
+${plan.content}
+
+Do not re-enter plan mode unless the user asks. Prefer executing the plan.`;
+        }
+        return "";
+    }
+    return `# Plan Mode (ACTIVE)
+You are in **plan mode**. Rules:
+1. Do NOT modify project source files (except the plan file at \`.apollo/plan.md\` via write_file).
+2. Prefer read-only tools: list_files, read_file, git_status, git_diff, web_search, web_fetch, skill_search, skill_read, memory_search, memory_list.
+3. Research thoroughly, then write a clear plan to \`.apollo/plan.md\` using write_file.
+4. Plan structure:
+   - Goal
+   - Approach
+   - Ordered steps
+   - Critical files
+   - Risks / open questions
+   - Verification
+5. When the plan is ready, tell the user to run \`/approve\` to exit plan mode and execute.
+6. Do not claim implementation is done while still in plan mode.`;
+}
+/** Read-only tools permitted in plan mode. Everything else is denied by default. */
+export function isPlanModeToolAllowed(toolName, input, workspaceRoot) {
+    if (toolName === "write_file") {
+        const p = typeof input.path === "string" ? input.path : "";
+        const planRel = ".apollo/plan.md";
+        const planAbs = path.join(workspaceRoot, planRel);
+        const resolved = path.isAbsolute(p) ? path.normalize(p) : path.normalize(path.join(workspaceRoot, p));
+        return resolved === path.normalize(planAbs);
+    }
+    return new Set([
+        "list_files",
+        "read_file",
+        "web_search",
+        "web_fetch",
+        "git_status",
+        "git_diff",
+        "request_human_approval",
+        "skill_search",
+        "skill_read",
+        "memory_search",
+        "memory_list",
+        "ask_user_question",
+    ]).has(toolName);
+}

package/dist/project-instructions.d.ts

@@ -0,0 +1,8 @@
+/** Same spirit as CLAUDE.md / AGENTS.md discovery. */
+export declare const PROJECT_INSTRUCTION_FILES: readonly ["APOLLO.md", "CLAUDE.md", "AGENTS.md", ".apollo/instructions.md", ".claude/CLAUDE.md"];
+export type ProjectInstructions = {
+    path: string;
+    content: string;
+};
+export declare function loadProjectInstructions(workspaceRoot: string, maxChars?: number): Promise<ProjectInstructions | null>;
+//# sourceMappingURL=project-instructions.d.ts.map