om-memory-system 3.0.0

package/dist/adapters/opencode/auto-capture-summary.js

@@ -0,0 +1,147 @@
+import { randomUUID } from "node:crypto";
+import { CONFIG } from "../../config.js";
+import { buildBoundedSummaryPrompt } from "../../core/capture-context.js";
+import { log } from "../../services/logger.js";
+import { loadOpencodeProvider } from "../../services/ai/opencode-provider-loader.js";
+function buildSystemPrompt(languageName) {
+    return `You are a technical memory recorder for a software development project.
+
+RULES:
+1. ONLY capture technical work (code, bugs, features, architecture, config)
+2. SKIP non-technical by returning type="skip"
+3. NO meta-commentary or behavior analysis
+4. Include specific file names, functions, technical details
+5. Generate 2-4 technical tags (e.g., "react", "auth", "bug-fix")
+6. You MUST write the summary in ${languageName}.
+
+FORMAT:
+## Request
+[1-2 sentences: what was requested, in ${languageName}]
+
+## Outcome
+[1-2 sentences: what was done, include files/functions, in ${languageName}]
+
+SKIP if: greetings, casual chat, no code/decisions made
+CAPTURE if: code changed, bug fixed, feature added, decision made`;
+}
+export async function generateOpenCodeAutoCaptureSummary(request, notify) {
+    let opencodeProviderError;
+    if (CONFIG.opencodeProvider && CONFIG.opencodeModel) {
+        try {
+            if (CONFIG.memoryModel) {
+                log("opencodeProvider takes precedence over memoryModel for auto-capture");
+            }
+            const { isProviderConnected, getV2Client, generateStructuredOutput } = await loadOpencodeProvider();
+            let providerID = CONFIG.opencodeProvider;
+            let modelID = CONFIG.opencodeModel;
+            if (modelID === "inherit") {
+                if (!request.prompt?.providerId || !request.prompt?.modelId) {
+                    throw new Error("omms: opencodeModel is 'inherit' but no session model was recorded for this prompt");
+                }
+                providerID = request.prompt.providerId;
+                modelID = request.prompt.modelId;
+            }
+            if (!isProviderConnected(providerID)) {
+                throw new Error(`opencode provider '${providerID}' is not connected. Check your opencode provider configuration.`);
+            }
+            const v2Client = getV2Client();
+            if (!v2Client) {
+                throw new Error("omms: v2 client not initialized; cannot perform structured-output capture");
+            }
+            const { detectLanguage, getLanguageName } = await import("../../services/language-detector.js");
+            const targetLang = CONFIG.autoCaptureLanguage === "auto" || !CONFIG.autoCaptureLanguage
+                ? detectLanguage(request.userPrompt)
+                : CONFIG.autoCaptureLanguage;
+            const systemPrompt = buildSystemPrompt(getLanguageName(targetLang));
+            const { z } = await import("zod");
+            const schema = z.object({
+                summary: z.string(),
+                type: z.string(),
+                tags: z.array(z.string()),
+            });
+            const aiPrompt = buildBoundedSummaryPrompt(request.context, systemPrompt, z.toJSONSchema(schema));
+            const result = await generateStructuredOutput({
+                client: v2Client,
+                providerID,
+                modelID,
+                systemPrompt,
+                userPrompt: aiPrompt,
+                schema,
+            });
+            return {
+                summary: result.summary,
+                type: result.type,
+                tags: (result.tags || []).map((tag) => tag.toLowerCase().trim()),
+            };
+        }
+        catch (error) {
+            opencodeProviderError = error;
+            log("auto-capture: opencode provider failed, falling back to external API", {
+                error: String(error),
+            });
+        }
+    }
+    if (!CONFIG.memoryModel || !CONFIG.memoryApiUrl) {
+        if (opencodeProviderError)
+            throw opencodeProviderError;
+        throw new Error("External API not configured for auto-capture");
+    }
+    if (opencodeProviderError && CONFIG.showErrorToasts && notify) {
+        const errMsg = opencodeProviderError instanceof Error
+            ? opencodeProviderError.message
+            : String(opencodeProviderError);
+        const shortReason = errMsg.length > 100 ? errMsg.substring(0, 100) + "..." : errMsg;
+        await Promise.resolve(notify({
+            title: "Using fallback provider",
+            message: `OpenCode provider failed (${shortReason}); using configured fallback.`,
+            variant: "warning",
+            duration: 5000,
+        })).catch(() => { });
+    }
+    const { AIProviderFactory } = await import("../../services/ai/ai-provider-factory.js");
+    const { buildMemoryProviderConfig } = await import("../../services/ai/provider-config.js");
+    const { detectLanguage, getLanguageName } = await import("../../services/language-detector.js");
+    const providerConfig = buildMemoryProviderConfig(CONFIG);
+    const provider = AIProviderFactory.createProvider(CONFIG.memoryProvider, providerConfig);
+    const targetLang = CONFIG.autoCaptureLanguage === "auto" || !CONFIG.autoCaptureLanguage
+        ? detectLanguage(request.userPrompt)
+        : CONFIG.autoCaptureLanguage;
+    const systemPrompt = buildSystemPrompt(getLanguageName(targetLang));
+    const toolSchema = {
+        type: "function",
+        function: {
+            name: "save_memory",
+            description: "Save the conversation summary as a memory",
+            parameters: {
+                type: "object",
+                properties: {
+                    summary: {
+                        type: "string",
+                        description: "Markdown-formatted summary of the conversation",
+                    },
+                    type: {
+                        type: "string",
+                        description: "Type of memory: 'skip' for non-technical conversations, or technical type (feature, bug-fix, refactor, analysis, configuration, discussion, other)",
+                    },
+                    tags: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "List of 2-4 technical tags related to the memory",
+                    },
+                },
+                required: ["summary", "type", "tags"],
+            },
+        },
+    };
+    const aiPrompt = buildBoundedSummaryPrompt(request.context, systemPrompt, toolSchema);
+    const captureSessionID = `auto-capture-${request.prompt?.id ?? request.sessionId}-${randomUUID()}`;
+    const result = await provider.executeToolCall(systemPrompt, aiPrompt, toolSchema, captureSessionID);
+    if (!result.success || !result.data) {
+        throw new Error(result.error || "Failed to generate summary");
+    }
+    return {
+        summary: result.data.summary,
+        type: result.data.type,
+        tags: (result.data.tags || []).map((tag) => tag.toLowerCase().trim()),
+    };
+}

package/dist/adapters/opencode/conversation.d.ts

@@ -0,0 +1,2 @@
+import type { CaptureConversation } from "../../core/host.js";
+export declare function extractOpenCodeConversation(messages: any[], promptMessageId: string): CaptureConversation | null;

package/dist/adapters/opencode/conversation.js

@@ -0,0 +1,50 @@
+const MAX_TOOL_INPUT_LENGTH = 100;
+export function extractOpenCodeConversation(messages, promptMessageId) {
+    const promptIndex = messages.findIndex((message) => message.info?.id === promptMessageId);
+    if (promptIndex === -1)
+        return null;
+    const responseMessages = [];
+    for (const message of messages.slice(promptIndex + 1)) {
+        if (message.info?.role === "user")
+            break;
+        responseMessages.push(message);
+    }
+    const textResponses = [];
+    const toolCalls = [];
+    const sourceEntryIds = [];
+    for (const message of responseMessages) {
+        if (message.info?.role !== "assistant")
+            continue;
+        if (typeof message.info?.id === "string")
+            sourceEntryIds.push(message.info.id);
+        if (!Array.isArray(message.parts))
+            continue;
+        const textParts = message.parts.filter((part) => part.type === "text" && typeof part.text === "string" && part.text.trim());
+        if (textParts.length > 0) {
+            textResponses.push(textParts
+                .map((part) => part.text)
+                .join("\n")
+                .trim());
+        }
+        for (const tool of message.parts.filter((part) => part.type === "tool")) {
+            const name = tool.tool || "unknown";
+            let input = "";
+            if (tool.state?.input) {
+                const inputValue = tool.state.input;
+                if (typeof inputValue === "string") {
+                    input = inputValue;
+                }
+                else if (typeof inputValue === "object") {
+                    input = Object.entries(inputValue)
+                        .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+                        .join(", ");
+                }
+            }
+            if (input.length > MAX_TOOL_INPUT_LENGTH) {
+                input = input.substring(0, MAX_TOOL_INPUT_LENGTH) + "...";
+            }
+            toolCalls.push({ name, input });
+        }
+    }
+    return { textResponses, toolCalls, sourceEntryIds };
+}

package/dist/adapters/opencode/user-prompt.d.ts

@@ -0,0 +1,9 @@
+export declare function isStructuredSummaryPromptMessage(userMessage: string): boolean;
+/** True when a prompt is omms's own internal traffic and must not be recorded or searched. */
+export declare function isInternalPrompt(sessionID: string, userMessage: string): boolean;
+/**
+ * Record a real user prompt so idle auto-capture can pair it with the session's
+ * response. Shared by the V1 `chat.message` hook and the v2 `prompt` hook.
+ * Returns false when the prompt is empty or internal and was not recorded.
+ */
+export declare function recordUserPrompt(sessionID: string, messageID: string, directory: string, userMessage: string): Promise<boolean>;

package/dist/adapters/opencode/user-prompt.js

@@ -0,0 +1,26 @@
+import { isInternalStructuredSession } from "../../services/ai/opencode-provider.js";
+import { userPromptManager } from "../../services/user-prompt/user-prompt-manager.js";
+export function isStructuredSummaryPromptMessage(userMessage) {
+    // This is the plugin's own structured-summary or profile-analysis request.
+    // OpenCode echoes it through chat.message like a normal user message, but
+    // capturing it would create self-referential memories / an infinite learning loop.
+    if (userMessage.includes("# User Profile Analysis")) {
+        return true;
+    }
+    return userMessage.includes("Analyze this conversation.") && userMessage.includes('type="skip"');
+}
+/** True when a prompt is omms's own internal traffic and must not be recorded or searched. */
+export function isInternalPrompt(sessionID, userMessage) {
+    return isStructuredSummaryPromptMessage(userMessage) || isInternalStructuredSession(sessionID);
+}
+/**
+ * Record a real user prompt so idle auto-capture can pair it with the session's
+ * response. Shared by the V1 `chat.message` hook and the v2 `prompt` hook.
+ * Returns false when the prompt is empty or internal and was not recorded.
+ */
+export async function recordUserPrompt(sessionID, messageID, directory, userMessage) {
+    if (!userMessage.trim() || isInternalPrompt(sessionID, userMessage))
+        return false;
+    await userPromptManager.savePrompt(sessionID, messageID, directory, userMessage);
+    return true;
+}

package/dist/adapters/pi/capture.d.ts

@@ -0,0 +1,41 @@
+import type { CaptureSummaryProvider } from "../../core/host.js";
+import { type PiSessionEntry } from "./conversation.js";
+export interface PiCaptureState {
+    /** User entry IDs terminally handled by a settled capture for this session. */
+    handledUserEntries: Set<string>;
+    running: boolean;
+}
+export declare function createPiCaptureState(): PiCaptureState;
+export interface PiSettledCaptureInput {
+    sessionId: string;
+    directory: string;
+    entries: PiSessionEntry[];
+    provider: CaptureSummaryProvider;
+    state: PiCaptureState;
+    prompt?: {
+        providerId?: string | null;
+        modelId?: string | null;
+    };
+    notify?: (notification: {
+        title: string;
+        message: string;
+        variant: "success" | "warning" | "error" | "info";
+    }) => Promise<void> | void;
+}
+export type PiSettledCaptureResult = {
+    status: "captured";
+    memoryId: string;
+} | {
+    status: "skipped";
+    reason: "disabled" | "busy" | "not-ready" | "no-window" | "already-handled" | "extractor-skip";
+} | {
+    status: "failed";
+    error: string;
+};
+/**
+ * Capture the work unit completed by the most recent user prompt on the
+ * settled branch. Safe to call for every `agent_settled` event: a work unit is
+ * processed at most once per user entry ID (live source identity), so retries,
+ * compaction continuation, and repeated settled events never double-capture.
+ */
+export declare function capturePiSettledWorkUnit(input: PiSettledCaptureInput): Promise<PiSettledCaptureResult>;

package/dist/adapters/pi/capture.js

@@ -0,0 +1,91 @@
+import { CONFIG } from "../../config.js";
+import { captureConversation } from "../../core/capture.js";
+import { log } from "../../services/logger.js";
+import { memoryClient } from "../../services/client.js";
+import { extractPiConversation } from "./conversation.js";
+export function createPiCaptureState() {
+    return { handledUserEntries: new Set(), running: false };
+}
+/**
+ * Capture the work unit completed by the most recent user prompt on the
+ * settled branch. Safe to call for every `agent_settled` event: a work unit is
+ * processed at most once per user entry ID (live source identity), so retries,
+ * compaction continuation, and repeated settled events never double-capture.
+ */
+export async function capturePiSettledWorkUnit(input) {
+    if (!CONFIG.autoCaptureEnabled)
+        return { status: "skipped", reason: "disabled" };
+    if (input.state.running)
+        return { status: "skipped", reason: "busy" };
+    input.state.running = true;
+    try {
+        const window = extractPiConversation(input.entries);
+        if (!window)
+            return { status: "skipped", reason: "no-window" };
+        if (input.state.handledUserEntries.has(window.userEntryId)) {
+            return { status: "skipped", reason: "already-handled" };
+        }
+        const embeddingInitError = memoryClient.getEmbeddingInitError?.();
+        if (embeddingInitError) {
+            return { status: "skipped", reason: "not-ready" };
+        }
+        const captureResult = await captureConversation({
+            host: "pi",
+            hostSessionId: input.sessionId,
+            sourceType: "live-capture",
+            projectDirectory: input.directory,
+            userPrompt: window.userPrompt,
+            promptId: window.userEntryId,
+            prompt: {
+                id: window.userEntryId,
+                providerId: input.prompt?.providerId ?? null,
+                modelId: input.prompt?.modelId ?? null,
+            },
+            textResponses: window.textResponses,
+            toolCalls: window.toolCalls,
+            sourceEntryIds: window.sourceEntryIds,
+            ...(window.sourceTimestamp !== undefined
+                ? { sourceTimestamp: window.sourceTimestamp }
+                : {}),
+        }, input.provider);
+        input.state.handledUserEntries.add(window.userEntryId);
+        if (captureResult.status === "skipped") {
+            log("Pi auto-capture skipped by extractor", {
+                sessionID: input.sessionId,
+                userEntryId: window.userEntryId,
+                type: captureResult.type,
+            });
+            return { status: "skipped", reason: "extractor-skip" };
+        }
+        log("Pi auto-capture memory persisted", {
+            sessionID: input.sessionId,
+            userEntryId: window.userEntryId,
+            memoryId: captureResult.memoryId,
+            host: "pi",
+        });
+        if (CONFIG.showAutoCaptureToasts && input.notify) {
+            await Promise.resolve(input.notify({
+                title: "Memory Captured",
+                message: "Project memory saved from conversation",
+                variant: "success",
+            })).catch(() => { });
+        }
+        return { status: "captured", memoryId: captureResult.memoryId };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log(`Pi auto-capture error: ${message}`, { sessionID: input.sessionId });
+        if (CONFIG.showErrorToasts && input.notify) {
+            const shortReason = message.length > 100 ? message.substring(0, 100) + "..." : message;
+            await Promise.resolve(input.notify({
+                title: "Auto Capture Failed",
+                message: shortReason,
+                variant: "error",
+            })).catch(() => { });
+        }
+        return { status: "failed", error: message };
+    }
+    finally {
+        input.state.running = false;
+    }
+}

package/dist/adapters/pi/conversation.d.ts

@@ -0,0 +1,38 @@
+import type { CaptureConversation } from "../../core/host.js";
+/**
+ * Minimal structural view of Pi session entries (see Pi session-format docs).
+ * Kept structural so the normaliser stays testable without importing Pi types.
+ */
+export interface PiSessionEntry {
+    type: string;
+    id: string;
+    parentId: string | null;
+    timestamp: string;
+    message?: {
+        role?: string;
+        content?: string | PiContentBlock[];
+    };
+}
+export interface PiContentBlock {
+    type: string;
+    text?: string;
+    thinking?: string;
+    name?: string;
+    arguments?: Record<string, unknown>;
+}
+export interface PiConversationWindow extends CaptureConversation {
+    userEntryId: string;
+    userPrompt: string;
+    userTimestamp?: number;
+}
+/**
+ * All capture windows on the branch, oldest first: one per user prompt that
+ * produced assistant or tool work. Used by live capture (last window) and by
+ * the historical importer (all windows).
+ */
+export declare function extractPiConversationWindows(entries: PiSessionEntry[]): PiConversationWindow[];
+/**
+ * The capture window of the most recent user prompt on the branch. Returns
+ * null when the branch has no user prompt with a response window.
+ */
+export declare function extractPiConversation(entries: PiSessionEntry[]): PiConversationWindow | null;

package/dist/adapters/pi/conversation.js

@@ -0,0 +1,118 @@
+const MAX_TOOL_INPUT_LENGTH = 100;
+function entryText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((block) => block.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("\n")
+        .trim();
+}
+function isUserEntry(entry) {
+    return entry.type === "message" && entry.message?.role === "user";
+}
+function isAssistantEntry(entry) {
+    return entry.type === "message" && entry.message?.role === "assistant";
+}
+function formatToolInput(args) {
+    if (!args)
+        return "";
+    return Object.entries(args)
+        .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+        .join(", ");
+}
+function boundToolInput(input) {
+    if (input.length > MAX_TOOL_INPUT_LENGTH) {
+        return input.substring(0, MAX_TOOL_INPUT_LENGTH) + "...";
+    }
+    return input;
+}
+/**
+ * Build the capture window for the user entry at `userIndex`: only that
+ * prompt's assistant/tool work, stopping at the next user message. Hidden
+ * thinking blocks are never included. Tool inputs are bounded by the same
+ * truncation policy as the OpenCode adapter.
+ *
+ * Returns null when the prompt is empty or has no assistant/tool response
+ * window yet.
+ */
+function buildWindow(entries, userIndex) {
+    const userEntry = entries[userIndex];
+    const userPrompt = entryText(userEntry.message?.content);
+    if (!userPrompt)
+        return null;
+    const textResponses = [];
+    const toolCalls = [];
+    const sourceEntryIds = [];
+    let sourceTimestamp;
+    for (const entry of entries.slice(userIndex + 1)) {
+        if (isUserEntry(entry))
+            break;
+        if (!isAssistantEntry(entry))
+            continue;
+        if (typeof entry.id === "string")
+            sourceEntryIds.push(entry.id);
+        const timestampMs = Date.parse(entry.timestamp);
+        if (!Number.isNaN(timestampMs))
+            sourceTimestamp = timestampMs;
+        const blocks = entry.message?.content;
+        if (!Array.isArray(blocks))
+            continue;
+        const textParts = blocks.filter((block) => block.type === "text" && typeof block.text === "string" && block.text.trim());
+        if (textParts.length > 0) {
+            textResponses.push(textParts
+                .map((block) => block.text)
+                .join("\n")
+                .trim());
+        }
+        for (const block of blocks.filter((item) => item.type === "toolCall")) {
+            const name = typeof block.name === "string" ? block.name : "unknown";
+            toolCalls.push({
+                name,
+                input: boundToolInput(formatToolInput(block.arguments)),
+            });
+        }
+    }
+    if (textResponses.length === 0 && toolCalls.length === 0)
+        return null;
+    const userTimestampMs = Date.parse(userEntry.timestamp);
+    return {
+        userEntryId: userEntry.id,
+        userPrompt,
+        textResponses,
+        toolCalls,
+        sourceEntryIds,
+        ...(sourceTimestamp !== undefined ? { sourceTimestamp } : {}),
+        ...(Number.isNaN(userTimestampMs) ? {} : { userTimestamp: userTimestampMs }),
+    };
+}
+/**
+ * All capture windows on the branch, oldest first: one per user prompt that
+ * produced assistant or tool work. Used by live capture (last window) and by
+ * the historical importer (all windows).
+ */
+export function extractPiConversationWindows(entries) {
+    const windows = [];
+    for (let i = 0; i < entries.length; i++) {
+        if (!isUserEntry(entries[i]))
+            continue;
+        const window = buildWindow(entries, i);
+        if (window)
+            windows.push(window);
+    }
+    return windows;
+}
+/**
+ * The capture window of the most recent user prompt on the branch. Returns
+ * null when the branch has no user prompt with a response window.
+ */
+export function extractPiConversation(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        if (!isUserEntry(entries[i]))
+            continue;
+        return buildWindow(entries, i);
+    }
+    return null;
+}

package/dist/adapters/pi/extension.d.ts

@@ -0,0 +1,18 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+/**
+ * Pi extension entry point for the shared omms engine.
+ *
+ * Lifecycle mapping:
+ * - `session_start`        -> load shared config for ctx.cwd, warm storage
+ * - `before_agent_start`   -> prompt-aware semantic retrieval, injected as a
+ *                             delimited system-prompt section (never a fake
+ *                             user message)
+ * - `agent_settled`        -> automatic capture of the settled work unit
+ * - `session_shutdown`     -> idempotent session-scoped cleanup
+ * - `memory` tool          -> shared add/search/profile/list/forget/help and
+ *                             portability operations
+ *
+ * Pi types are imported type-only: the compiled extension carries no Pi
+ * runtime dependency and uses the host Pi runtime provided at load time.
+ */
+export default function ommsPiExtension(pi: ExtensionAPI): void;