om-memory-system 3.0.0

package/dist/core/capture-context.d.ts

@@ -0,0 +1,4 @@
+import type { CaptureToolCall } from "./host.js";
+export declare function getAutoCaptureMarkdownBudget(totalRequestBytes?: number): number;
+export declare function buildBoundedSummaryPrompt(context: string, systemPrompt: string, schema: unknown, totalRequestBytes?: number): string;
+export declare function buildMarkdownContext(userPrompt: string, textResponses: string[], toolCalls: CaptureToolCall[], latestMemory: string | null, maxContextBytes?: number): string;

package/dist/core/capture-context.js

@@ -0,0 +1,132 @@
+import { CONFIG } from "../config.js";
+import { truncateToMaxBytes, utf8ByteLength } from "../utils/context-limit.js";
+const DEFAULT_AUTO_CAPTURE_MAX_CONTEXT_BYTES = 131072;
+const CONTEXT_TRUNCATION_MARKER = "\n[... truncated to autoCaptureMaxContextBytes ...]\n";
+const SUMMARY_REQUEST_OVERHEAD_BYTES = 1024;
+const SUMMARY_OUTPUT_RESERVE_BYTES = 16384;
+const SUMMARY_ANALYSIS_SUFFIX = 'Analyze this conversation. If it contains technical work (code, bugs, features, decisions), create a concise summary and relevant tags. If it\'s non-technical (greetings, casual chat, incomplete requests), return type="skip" with empty summary.';
+function fitTextResponses(textResponses, maxBytes) {
+    if (textResponses.length === 0 || maxBytes <= 0)
+        return "";
+    const separator = "\n\n";
+    const separatorBytes = utf8ByteLength(separator);
+    const joined = textResponses.join(separator);
+    if (utf8ByteLength(joined) <= maxBytes)
+        return joined;
+    const kept = [];
+    let usedBytes = 0;
+    for (let i = textResponses.length - 1; i >= 0; i--) {
+        const response = textResponses[i] ?? "";
+        const responseBytes = utf8ByteLength(response);
+        const extraSeparator = kept.length > 0 ? separatorBytes : 0;
+        const needed = responseBytes + extraSeparator;
+        if (usedBytes + needed <= maxBytes) {
+            kept.unshift(response);
+            usedBytes += needed;
+            continue;
+        }
+        const remaining = maxBytes - usedBytes - extraSeparator;
+        if (remaining > utf8ByteLength(CONTEXT_TRUNCATION_MARKER)) {
+            kept.unshift(truncateToMaxBytes(response, remaining, CONTEXT_TRUNCATION_MARKER));
+        }
+        break;
+    }
+    return kept.join(separator);
+}
+function joinSections(sections) {
+    return sections.join("\n");
+}
+export function getAutoCaptureMarkdownBudget(totalRequestBytes = CONFIG.autoCaptureMaxContextBytes ??
+    DEFAULT_AUTO_CAPTURE_MAX_CONTEXT_BYTES) {
+    const requestReserve = Math.min(24576, Math.floor(totalRequestBytes * 0.25));
+    return Math.max(4096, totalRequestBytes - requestReserve);
+}
+export function buildBoundedSummaryPrompt(context, systemPrompt, schema, totalRequestBytes = CONFIG.autoCaptureMaxContextBytes ??
+    DEFAULT_AUTO_CAPTURE_MAX_CONTEXT_BYTES) {
+    const schemaBytes = utf8ByteLength(JSON.stringify(schema));
+    const outputReserve = Math.min(SUMMARY_OUTPUT_RESERVE_BYTES, Math.floor(totalRequestBytes * 0.125));
+    const userBudget = Math.max(0, totalRequestBytes -
+        utf8ByteLength(systemPrompt) -
+        schemaBytes -
+        outputReserve -
+        SUMMARY_REQUEST_OVERHEAD_BYTES);
+    return truncateToMaxBytes(`${context}\n\n${SUMMARY_ANALYSIS_SUFFIX}`, userBudget, CONTEXT_TRUNCATION_MARKER);
+}
+export function buildMarkdownContext(userPrompt, textResponses, toolCalls, latestMemory, maxContextBytes = CONFIG.autoCaptureMaxContextBytes ??
+    DEFAULT_AUTO_CAPTURE_MAX_CONTEXT_BYTES) {
+    const memorySections = [];
+    if (latestMemory) {
+        memorySections.push("## Previous Memory Context");
+        memorySections.push("---");
+        memorySections.push(latestMemory);
+        memorySections.push("---\n");
+    }
+    const toolsSections = [];
+    if (toolCalls.length > 0) {
+        toolsSections.push("## Tools Used");
+        toolsSections.push("---");
+        for (const tool of toolCalls) {
+            toolsSections.push(tool.input ? `- ${tool.name}(${tool.input})` : `- ${tool.name}`);
+        }
+        toolsSections.push("---\n");
+    }
+    const userWrapper = ["## User Request", "---", "", "---\n"];
+    const aiWrapper = textResponses.length > 0 ? ["## AI Response", "---", "", "---\n"] : [];
+    const skeletonWithoutBodies = joinSections([
+        ...memorySections,
+        ...userWrapper,
+        ...aiWrapper,
+        ...toolsSections,
+    ]);
+    const skeletonBytes = utf8ByteLength(skeletonWithoutBodies);
+    let userBudget = Math.max(0, maxContextBytes - skeletonBytes);
+    if (textResponses.length > 0 && userBudget > 1024) {
+        const preferredAiFloor = Math.min(4096, Math.floor(maxContextBytes * 0.25));
+        userBudget = Math.max(256, userBudget - preferredAiFloor);
+    }
+    const boundedUser = utf8ByteLength(userPrompt) <= userBudget
+        ? userPrompt
+        : truncateToMaxBytes(userPrompt, userBudget, CONTEXT_TRUNCATION_MARKER);
+    const prefix = joinSections([
+        ...memorySections,
+        "## User Request",
+        "---",
+        boundedUser,
+        "---\n",
+        ...toolsSections,
+    ]);
+    if (textResponses.length === 0) {
+        if (utf8ByteLength(prefix) <= maxContextBytes)
+            return prefix;
+        return truncateToMaxBytes(prefix, maxContextBytes, CONTEXT_TRUNCATION_MARKER);
+    }
+    const prefixWithoutTools = joinSections([
+        ...memorySections,
+        "## User Request",
+        "---",
+        boundedUser,
+        "---\n",
+    ]);
+    const toolsBlock = toolsSections.length > 0 ? "\n" + joinSections(toolsSections) : "";
+    const aiWrapperBytes = utf8ByteLength(joinSections(["## AI Response", "---", "", "---\n"]));
+    const aiBudget = Math.max(0, maxContextBytes -
+        utf8ByteLength(prefixWithoutTools) -
+        utf8ByteLength(toolsBlock) -
+        aiWrapperBytes);
+    const boundedAi = fitTextResponses(textResponses, aiBudget);
+    const result = joinSections([
+        ...memorySections,
+        "## User Request",
+        "---",
+        boundedUser,
+        "---\n",
+        "## AI Response",
+        "---",
+        boundedAi,
+        "---\n",
+        ...toolsSections,
+    ]);
+    if (utf8ByteLength(result) <= maxContextBytes)
+        return result;
+    return truncateToMaxBytes(result, maxContextBytes, CONTEXT_TRUNCATION_MARKER);
+}

package/dist/core/capture.d.ts

@@ -0,0 +1,15 @@
+import type { CaptureConversation, CapturePromptContext, CaptureProvenance, CaptureSummaryProvider } from "./host.js";
+export interface CaptureWorkUnit extends CaptureProvenance, CaptureConversation {
+    projectDirectory: string;
+    userPrompt: string;
+    promptId?: string;
+    prompt?: CapturePromptContext;
+}
+export type CaptureResult = {
+    status: "captured";
+    memoryId: string;
+} | {
+    status: "skipped";
+    type?: string;
+};
+export declare function captureConversation(workUnit: CaptureWorkUnit, provider: CaptureSummaryProvider): Promise<CaptureResult>;

package/dist/core/capture.js

@@ -0,0 +1,68 @@
+import { memoryClient } from "../services/client.js";
+import { getTags } from "../services/tags.js";
+import { buildMarkdownContext, getAutoCaptureMarkdownBudget } from "./capture-context.js";
+async function getLatestProjectMemory(containerTag) {
+    try {
+        const result = await memoryClient.listMemories(containerTag, 1);
+        if (!result.success || result.memories.length === 0)
+            return null;
+        const latest = result.memories[0];
+        if (!latest)
+            return null;
+        return latest.summary.length <= 500 ? latest.summary : latest.summary.substring(0, 500) + "...";
+    }
+    catch {
+        return null;
+    }
+}
+export async function captureConversation(workUnit, provider) {
+    const tags = getTags(workUnit.projectDirectory);
+    const latestMemory = await getLatestProjectMemory(tags.project.tag);
+    const context = buildMarkdownContext(workUnit.userPrompt, workUnit.textResponses, workUnit.toolCalls, latestMemory, getAutoCaptureMarkdownBudget());
+    let summaryResult;
+    try {
+        summaryResult = await provider.summarize({
+            context,
+            sessionId: workUnit.hostSessionId,
+            projectDirectory: workUnit.projectDirectory,
+            userPrompt: workUnit.userPrompt,
+            prompt: workUnit.prompt,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Summary generation failed: ${message}`, { cause: error });
+    }
+    if (!summaryResult || summaryResult.type === "skip") {
+        return { status: "skipped", type: summaryResult?.type };
+    }
+    const summaryWithTags = summaryResult.tags.length > 0
+        ? `${summaryResult.summary}\n\nTags: ${summaryResult.tags.join(", ")}`
+        : summaryResult.summary;
+    const source = workUnit.sourceType === "history-import" ? "import" : "auto-capture";
+    const result = await memoryClient.addMemory(summaryWithTags, tags.project.tag, {
+        source,
+        type: summaryResult.type,
+        tags: summaryResult.tags,
+        sessionID: workUnit.hostSessionId,
+        promptId: workUnit.promptId,
+        captureTimestamp: Date.now(),
+        host: workUnit.host,
+        hostSessionId: workUnit.hostSessionId,
+        sourceType: workUnit.sourceType,
+        sourceEntryIds: workUnit.sourceEntryIds,
+        sourceTimestamp: workUnit.sourceTimestamp,
+        sourceFile: workUnit.sourceFile,
+        importId: workUnit.importId,
+        displayName: tags.project.displayName,
+        userName: tags.project.userName,
+        userEmail: tags.project.userEmail,
+        projectPath: tags.project.projectPath,
+        projectName: tags.project.projectName,
+        gitRepoUrl: tags.project.gitRepoUrl,
+    });
+    if (!result.success) {
+        throw new Error(`Memory persistence failed: ${result.error || "database write failed"}`);
+    }
+    return { status: "captured", memoryId: result.id };
+}

package/dist/core/extraction.d.ts

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import type { CaptureSummary } from "./host.js";
+/**
+ * Shared structured-extraction contract for automatic capture.
+ *
+ * Both host adapters (OpenCode provider path and the Pi model bridge) request
+ * the same summary shape and validate model output against this schema so the
+ * downstream capture pipeline always receives well-formed results.
+ */
+export declare const captureSummarySchema: z.ZodObject<{
+    summary: z.ZodString;
+    type: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * JSON schema description embedded into the summary request prompt. Kept as a
+ * plain object so it can be passed to hosts that take a tool-schema style
+ * description (OpenCode fallback path, Pi bridge prompt).
+ */
+export declare const captureSummaryToolSchema: {
+    type: "object";
+    properties: {
+        summary: {
+            type: string;
+            description: string;
+        };
+        type: {
+            type: string;
+            description: string;
+        };
+        tags: {
+            type: string;
+            items: {
+                type: string;
+            };
+            description: string;
+        };
+    };
+    required: string[];
+};
+export declare function buildCaptureSystemPrompt(languageName: string): string;
+/** Upper bound for LLM-inferred preference confidence (0–1 scale). */
+export declare const USER_PROFILE_LLM_CONFIDENCE_MAX = 1;
+/**
+ * Shared user-profile analysis schema used by OpenCode structured output,
+ * the external fallback provider, and the Pi model bridge.
+ */
+export declare function createUserProfileAnalysisSchema(z: typeof import("zod").z): z.ZodObject<{
+    preferences: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    patterns: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    workflows: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        steps: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    validations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        verdict: z.ZodEnum<{
+            confirmed: "confirmed";
+            contradicted: "contradicted";
+            no_evidence: "no_evidence";
+            inaccurate: "inaccurate";
+            oversimplified: "oversimplified";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare function extractJsonObject(raw: string): unknown;
+/**
+ * Parse and validate a model reply as a capture summary. Tolerates fenced code
+ * blocks and surrounding prose. Returns null when no valid payload is present.
+ */
+export declare function parseCaptureSummary(raw: string): CaptureSummary | null;

package/dist/core/extraction.js

@@ -0,0 +1,140 @@
+import { z } from "zod";
+/**
+ * Shared structured-extraction contract for automatic capture.
+ *
+ * Both host adapters (OpenCode provider path and the Pi model bridge) request
+ * the same summary shape and validate model output against this schema so the
+ * downstream capture pipeline always receives well-formed results.
+ */
+export const captureSummarySchema = z.object({
+    summary: z.string(),
+    type: z.string(),
+    tags: z.array(z.string()),
+});
+/**
+ * JSON schema description embedded into the summary request prompt. Kept as a
+ * plain object so it can be passed to hosts that take a tool-schema style
+ * description (OpenCode fallback path, Pi bridge prompt).
+ */
+export const captureSummaryToolSchema = {
+    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"],
+};
+export function buildCaptureSystemPrompt(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`;
+}
+/** Upper bound for LLM-inferred preference confidence (0–1 scale). */
+export const USER_PROFILE_LLM_CONFIDENCE_MAX = 1;
+/**
+ * Shared user-profile analysis schema used by OpenCode structured output,
+ * the external fallback provider, and the Pi model bridge.
+ */
+export function createUserProfileAnalysisSchema(z) {
+    return z.object({
+        preferences: z.array(z.object({
+            category: z.string(),
+            description: z.string(),
+            confidence: z.number().min(0).max(USER_PROFILE_LLM_CONFIDENCE_MAX),
+            evidence: z.array(z.string()),
+        })),
+        patterns: z.array(z.object({
+            category: z.string(),
+            description: z.string(),
+        })),
+        workflows: z.array(z.object({
+            description: z.string(),
+            steps: z.array(z.string()),
+        })),
+        validations: z
+            .array(z.object({
+            index: z.number(),
+            verdict: z.enum([
+                "confirmed",
+                "contradicted",
+                "no_evidence",
+                "inaccurate",
+                "oversimplified",
+            ]),
+            reason: z.string(),
+        }))
+            .optional(),
+    });
+}
+export function extractJsonObject(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("{")) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            // fall through to fenced-block extraction
+        }
+    }
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fenced?.[1]) {
+        try {
+            return JSON.parse(fenced[1].trim());
+        }
+        catch {
+            return null;
+        }
+    }
+    const braceStart = trimmed.indexOf("{");
+    const braceEnd = trimmed.lastIndexOf("}");
+    if (braceStart !== -1 && braceEnd > braceStart) {
+        try {
+            return JSON.parse(trimmed.slice(braceStart, braceEnd + 1));
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Parse and validate a model reply as a capture summary. Tolerates fenced code
+ * blocks and surrounding prose. Returns null when no valid payload is present.
+ */
+export function parseCaptureSummary(raw) {
+    const parsed = captureSummarySchema.safeParse(extractJsonObject(raw));
+    if (!parsed.success)
+        return null;
+    return {
+        summary: parsed.data.summary,
+        type: parsed.data.type,
+        tags: parsed.data.tags.map((tag) => tag.toLowerCase().trim()).filter(Boolean),
+    };
+}

package/dist/core/host.d.ts

@@ -0,0 +1,52 @@
+import type { MemoryHost, MemorySourceType } from "../types/index.js";
+export interface CaptureToolCall {
+    name: string;
+    input: string;
+}
+export interface CaptureConversation {
+    textResponses: string[];
+    toolCalls: CaptureToolCall[];
+    sourceEntryIds?: string[];
+    sourceTimestamp?: number;
+}
+export interface CapturePromptContext {
+    id?: string;
+    providerId?: string | null;
+    modelId?: string | null;
+}
+export interface CaptureSummary {
+    summary: string;
+    type: string;
+    tags: string[];
+}
+export interface CaptureSummaryRequest {
+    context: string;
+    sessionId: string;
+    projectDirectory: string;
+    userPrompt: string;
+    prompt?: CapturePromptContext;
+}
+export interface CaptureSummaryProvider {
+    summarize(request: CaptureSummaryRequest): Promise<CaptureSummary | null>;
+}
+export interface AutoCaptureNotification {
+    title: string;
+    message: string;
+    variant: "success" | "warning" | "error" | "info";
+    duration: number;
+}
+export interface AutoCaptureHost extends CaptureSummaryProvider {
+    readonly host: MemoryHost;
+    isCaptureReady(): boolean;
+    getConversation(sessionId: string, promptMessageId: string): Promise<CaptureConversation | null>;
+    notify?(notification: AutoCaptureNotification): Promise<void> | void;
+}
+export interface CaptureProvenance {
+    host: MemoryHost;
+    hostSessionId: string;
+    sourceType: MemorySourceType;
+    sourceEntryIds?: string[];
+    sourceTimestamp?: number;
+    sourceFile?: string;
+    importId?: string;
+}

package/dist/core/host.js

@@ -0,0 +1 @@
+export {};

package/dist/core/memory-operations.d.ts

@@ -0,0 +1,27 @@
+import { type MemoryScope } from "../services/client.js";
+import { getTags } from "../services/tags.js";
+import type { MemoryHost, MemoryType } from "../types/index.js";
+export type MemoryOperationMode = "add" | "search" | "profile" | "list" | "forget" | "help" | "migrate" | "list-shards" | "export" | "import";
+export interface MemoryOperationArgs {
+    mode?: MemoryOperationMode;
+    content?: string;
+    query?: string;
+    tags?: string;
+    type?: MemoryType;
+    memoryId?: string;
+    limit?: number;
+    scope?: MemoryScope;
+    fromPath?: string;
+    fromHash?: string;
+    outputPath?: string;
+    inputPath?: string;
+    dryRun?: boolean;
+    allowLinkedSource?: boolean;
+}
+export interface MemoryOperationContext {
+    directory: string;
+    tags?: ReturnType<typeof getTags>;
+    host?: MemoryHost;
+    hostSessionId?: string;
+}
+export declare function executeMemoryOperation(args: MemoryOperationArgs, context: MemoryOperationContext): Promise<Record<string, unknown>>;