@xiaoxiamimengfb/my-opencode-mem 2.12.0

package/dist/services/auto-capture.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function performAutoCapture(ctx: PluginInput, sessionID: string, directory: string): Promise<void>;
+//# sourceMappingURL=auto-capture.d.ts.map

package/dist/services/auto-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-capture.d.ts","sourceRoot":"","sources":["../../src/services/auto-capture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAgBvD,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,WAAW,EAChB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CA2Ff"}

package/dist/services/auto-capture.js

@@ -0,0 +1,306 @@
+import { memoryClient } from "./client.js";
+import { getTags } from "./tags.js";
+import { log } from "./logger.js";
+import { CONFIG } from "../config.js";
+import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
+const MAX_TOOL_INPUT_LENGTH = 100;
+let isCaptureRunning = false;
+export async function performAutoCapture(ctx, sessionID, directory) {
+    if (isCaptureRunning)
+        return;
+    isCaptureRunning = true;
+    try {
+        const prompt = userPromptManager.getLastUncapturedPrompt(sessionID);
+        if (!prompt) {
+            return;
+        }
+        if (!userPromptManager.claimPrompt(prompt.id)) {
+            return;
+        }
+        if (!ctx.client) {
+            throw new Error("Client not available");
+        }
+        const response = await ctx.client.session.messages({
+            path: { id: sessionID },
+        });
+        if (!response.data) {
+            return;
+        }
+        const messages = response.data;
+        const promptIndex = messages.findIndex((m) => m.info?.id === prompt.messageId);
+        if (promptIndex === -1) {
+            return;
+        }
+        const aiMessages = messages.slice(promptIndex + 1);
+        if (aiMessages.length === 0) {
+            return;
+        }
+        const { textResponses, toolCalls } = extractAIContent(aiMessages);
+        if (textResponses.length === 0 && toolCalls.length === 0) {
+            return;
+        }
+        const tags = getTags(directory);
+        const latestMemory = await getLatestProjectMemory(tags.project.tag);
+        const context = buildMarkdownContext(prompt.content, textResponses, toolCalls, latestMemory);
+        const summaryResult = await generateSummary(context, sessionID, prompt.content);
+        if (!summaryResult || summaryResult.type === "skip") {
+            userPromptManager.deletePrompt(prompt.id);
+            return;
+        }
+        const result = await memoryClient.addMemory(summaryResult.summary, tags.project.tag, {
+            source: "auto-capture",
+            type: summaryResult.type,
+            tags: summaryResult.tags,
+            sessionID,
+            promptId: prompt.id,
+            captureTimestamp: Date.now(),
+            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) {
+            userPromptManager.linkMemoryToPrompt(prompt.id, result.id);
+            userPromptManager.markAsCaptured(prompt.id);
+            if (CONFIG.showAutoCaptureToasts) {
+                await ctx.client?.tui
+                    .showToast({
+                    body: {
+                        title: "Memory Captured",
+                        message: "Project memory saved from conversation",
+                        variant: "success",
+                        duration: 3000,
+                    },
+                })
+                    .catch(() => { });
+            }
+        }
+    }
+    finally {
+        isCaptureRunning = false;
+    }
+}
+function extractAIContent(messages) {
+    const textResponses = [];
+    const toolCalls = [];
+    for (const msg of messages) {
+        if (msg.info?.role !== "assistant")
+            continue;
+        if (!msg.parts || !Array.isArray(msg.parts))
+            continue;
+        const textParts = msg.parts.filter((p) => p.type === "text" && p.text);
+        if (textParts.length > 0) {
+            const text = textParts.map((p) => p.text).join("\n");
+            if (text.trim()) {
+                textResponses.push(text.trim());
+            }
+        }
+        const toolParts = msg.parts.filter((p) => p.type === "tool");
+        for (const tool of toolParts) {
+            const name = tool.tool || "unknown";
+            let input = "";
+            if (tool.state?.input) {
+                const inputObj = tool.state.input;
+                if (typeof inputObj === "string") {
+                    input = inputObj;
+                }
+                else if (typeof inputObj === "object") {
+                    const params = [];
+                    for (const [key, value] of Object.entries(inputObj)) {
+                        params.push(`${key}: ${JSON.stringify(value)}`);
+                    }
+                    input = params.join(", ");
+                }
+            }
+            if (input.length > MAX_TOOL_INPUT_LENGTH) {
+                input = input.substring(0, MAX_TOOL_INPUT_LENGTH) + "...";
+            }
+            toolCalls.push({ name, input });
+        }
+    }
+    return { textResponses, toolCalls };
+}
+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;
+        }
+        const content = latest.summary;
+        if (content.length <= 500) {
+            return content;
+        }
+        return content.substring(0, 500) + "...";
+    }
+    catch {
+        return null;
+    }
+}
+function buildMarkdownContext(userPrompt, textResponses, toolCalls, latestMemory) {
+    const sections = [];
+    if (latestMemory) {
+        sections.push(`## Previous Memory Context`);
+        sections.push(`---`);
+        sections.push(latestMemory);
+        sections.push(`---\n`);
+    }
+    sections.push(`## User Request`);
+    sections.push(`---`);
+    sections.push(userPrompt);
+    sections.push(`---\n`);
+    if (textResponses.length > 0) {
+        sections.push(`## AI Response`);
+        sections.push(`---`);
+        sections.push(textResponses.join("\n\n"));
+        sections.push(`---\n`);
+    }
+    if (toolCalls.length > 0) {
+        sections.push(`## Tools Used`);
+        sections.push(`---`);
+        for (const tool of toolCalls) {
+            if (tool.input) {
+                sections.push(`- ${tool.name}(${tool.input})`);
+            }
+            else {
+                sections.push(`- ${tool.name}`);
+            }
+        }
+        sections.push(`---\n`);
+    }
+    return sections.join("\n");
+}
+async function generateSummary(context, sessionID, userPrompt) {
+    // Opencode provider path (when opencodeProvider + opencodeModel configured)
+    if (CONFIG.opencodeProvider && CONFIG.opencodeModel) {
+        if (CONFIG.memoryModel) {
+            log("opencodeProvider takes precedence over memoryModel for auto-capture");
+        }
+        const { isProviderConnected, getStatePath, generateStructuredOutput } = await import("./ai/opencode-provider.js");
+        if (!isProviderConnected(CONFIG.opencodeProvider)) {
+            throw new Error(`opencode provider '${CONFIG.opencodeProvider}' is not connected. Check your opencode provider configuration.`);
+        }
+        const { detectLanguage, getLanguageName } = await import("./language-detector.js");
+        const targetLang = CONFIG.autoCaptureLanguage === "auto" || !CONFIG.autoCaptureLanguage
+            ? detectLanguage(userPrompt)
+            : CONFIG.autoCaptureLanguage;
+        const langName = getLanguageName(targetLang);
+        const systemPrompt = `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 ${langName}.
+
+FORMAT:
+## Request
+[1-2 sentences: what was requested, in ${langName}]
+
+## Outcome
+[1-2 sentences: what was done, include files/functions, in ${langName}]
+
+SKIP if: greetings, casual chat, no code/decisions made
+CAPTURE if: code changed, bug fixed, feature added, decision made`;
+        const aiPrompt = `${context}
+
+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.`;
+        const { z } = await import("zod");
+        const schema = z.object({
+            summary: z.string(),
+            type: z.string(),
+            tags: z.array(z.string()),
+        });
+        const result = await generateStructuredOutput({
+            providerName: CONFIG.opencodeProvider,
+            modelId: CONFIG.opencodeModel,
+            statePath: getStatePath(),
+            systemPrompt,
+            userPrompt: aiPrompt,
+            schema,
+            temperature: CONFIG.memoryTemperature === false ? undefined : (CONFIG.memoryTemperature ?? 0.3),
+        });
+        return {
+            summary: result.summary,
+            type: result.type,
+            tags: (result.tags || []).map((t) => t.toLowerCase().trim()),
+        };
+    }
+    // Existing manual config path
+    if (!CONFIG.memoryModel || !CONFIG.memoryApiUrl) {
+        throw new Error("External API not configured for auto-capture");
+    }
+    const { AIProviderFactory } = await import("./ai/ai-provider-factory.js");
+    const { buildMemoryProviderConfig } = await import("./ai/provider-config.js");
+    const { detectLanguage, getLanguageName } = await import("./language-detector.js");
+    const providerConfig = buildMemoryProviderConfig(CONFIG);
+    const provider = AIProviderFactory.createProvider(CONFIG.memoryProvider, providerConfig);
+    const targetLang = CONFIG.autoCaptureLanguage === "auto" || !CONFIG.autoCaptureLanguage
+        ? detectLanguage(userPrompt)
+        : CONFIG.autoCaptureLanguage;
+    const langName = getLanguageName(targetLang);
+    const systemPrompt = `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 ${langName}.
+
+FORMAT:
+## Request
+[1-2 sentences: what was requested, in ${langName}]
+
+## Outcome
+[1-2 sentences: what was done, include files/functions, in ${langName}]
+
+SKIP if: greetings, casual chat, no code/decisions made
+CAPTURE if: code changed, bug fixed, feature added, decision made`;
+    const aiPrompt = `${context}
+
+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.`;
+    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 result = await provider.executeToolCall(systemPrompt, aiPrompt, toolSchema, sessionID);
+    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((t) => t.toLowerCase().trim()),
+    };
+}

package/dist/services/cleanup-service.d.ts

@@ -0,0 +1,23 @@
+interface CleanupResult {
+    deletedCount: number;
+    userCount: number;
+    projectCount: number;
+    promptsDeleted: number;
+    linkedMemoriesDeleted: number;
+    pinnedMemoriesSkipped: number;
+}
+export declare class CleanupService {
+    private lastCleanupTime;
+    private isRunning;
+    shouldRunCleanup(): Promise<boolean>;
+    runCleanup(): Promise<CleanupResult>;
+    getStatus(): {
+        enabled: boolean;
+        retentionDays: number;
+        lastCleanupTime: number;
+        isRunning: boolean;
+    };
+}
+export declare const cleanupService: CleanupService;
+export {};
+//# sourceMappingURL=cleanup-service.d.ts.map

package/dist/services/cleanup-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup-service.d.ts","sourceRoot":"","sources":["../../src/services/cleanup-service.ts"],"names":[],"mappings":"AAOA,UAAU,aAAa;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,SAAS,CAAkB;IAE7B,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC;IAcpC,UAAU,IAAI,OAAO,CAAC,aAAa,CAAC;IAsF1C,SAAS;;;;;;CAQV;AAED,eAAO,MAAM,cAAc,gBAAuB,CAAC"}

package/dist/services/cleanup-service.js

@@ -0,0 +1,102 @@
+import { shardManager } from "./sqlite/shard-manager.js";
+import { vectorSearch } from "./sqlite/vector-search.js";
+import { connectionManager } from "./sqlite/connection-manager.js";
+import { CONFIG } from "../config.js";
+import { log } from "./logger.js";
+import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
+export class CleanupService {
+    lastCleanupTime = 0;
+    isRunning = false;
+    async shouldRunCleanup() {
+        if (!CONFIG.autoCleanupEnabled)
+            return false;
+        if (this.isRunning)
+            return false;
+        const now = Date.now();
+        const oneDayMs = 24 * 60 * 60 * 1000;
+        if (now - this.lastCleanupTime < oneDayMs) {
+            return false;
+        }
+        return true;
+    }
+    async runCleanup() {
+        if (this.isRunning) {
+            throw new Error("Cleanup already running");
+        }
+        this.isRunning = true;
+        this.lastCleanupTime = Date.now();
+        try {
+            const cutoffTime = Date.now() - CONFIG.autoCleanupRetentionDays * 24 * 60 * 60 * 1000;
+            const userShards = shardManager.getAllShards("user", "");
+            const projectShards = shardManager.getAllShards("project", "");
+            const allShards = [...userShards, ...projectShards];
+            const pinnedMemoryIds = new Set();
+            for (const shard of allShards) {
+                const db = connectionManager.getConnection(shard.dbPath);
+                const pinned = db.prepare(`SELECT id FROM memories WHERE is_pinned = 1`).all();
+                pinned.forEach((row) => pinnedMemoryIds.add(row.id));
+            }
+            const promptCleanupResult = userPromptManager.deleteOldPrompts(cutoffTime);
+            const linkedMemoryIds = new Set(promptCleanupResult.linkedMemoryIds);
+            const protectedMemoryIds = new Set([...pinnedMemoryIds, ...linkedMemoryIds]);
+            let totalDeleted = 0;
+            let userDeleted = 0;
+            let projectDeleted = 0;
+            let linkedMemoriesDeleted = 0;
+            let pinnedSkipped = 0;
+            for (const shard of allShards) {
+                const db = connectionManager.getConnection(shard.dbPath);
+                const oldMemories = db
+                    .prepare(`
+          SELECT id, container_tag, is_pinned FROM memories 
+          WHERE updated_at < ?
+        `)
+                    .all(cutoffTime);
+                for (const memory of oldMemories) {
+                    try {
+                        if (memory.is_pinned === 1) {
+                            pinnedSkipped++;
+                            continue;
+                        }
+                        if (protectedMemoryIds.has(memory.id)) {
+                            continue;
+                        }
+                        await vectorSearch.deleteVector(db, memory.id, shard);
+                        shardManager.decrementVectorCount(shard.id);
+                        totalDeleted++;
+                        if (memory.container_tag?.includes("_user_")) {
+                            userDeleted++;
+                        }
+                        else if (memory.container_tag?.includes("_project_")) {
+                            projectDeleted++;
+                        }
+                    }
+                    catch (error) {
+                        log("Cleanup: delete error", { memoryId: memory.id, error: String(error) });
+                    }
+                }
+            }
+            const promptsDeleted = promptCleanupResult.deleted - linkedMemoryIds.size;
+            return {
+                deletedCount: totalDeleted,
+                userCount: userDeleted,
+                projectCount: projectDeleted,
+                promptsDeleted,
+                linkedMemoriesDeleted,
+                pinnedMemoriesSkipped: pinnedSkipped,
+            };
+        }
+        finally {
+            this.isRunning = false;
+        }
+    }
+    getStatus() {
+        return {
+            enabled: CONFIG.autoCleanupEnabled,
+            retentionDays: CONFIG.autoCleanupRetentionDays,
+            lastCleanupTime: this.lastCleanupTime,
+            isRunning: this.isRunning,
+        };
+    }
+}
+export const cleanupService = new CleanupService();

package/dist/services/client.d.ts

@@ -0,0 +1,118 @@
+import type { MemoryType } from "../types/index.js";
+export declare class LocalMemoryClient {
+    private initPromise;
+    private isInitialized;
+    constructor();
+    private initialize;
+    warmup(progressCallback?: (progress: any) => void): Promise<void>;
+    isReady(): Promise<boolean>;
+    getStatus(): {
+        dbConnected: boolean;
+        modelLoaded: boolean;
+        ready: boolean;
+    };
+    close(): void;
+    searchMemories(query: string, containerTag: string): Promise<{
+        success: true;
+        results: import("./sqlite/types.js").SearchResult[];
+        total: number;
+        timing: number;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        results: never[];
+        total: number;
+        timing: number;
+    }>;
+    addMemory(content: string, containerTag: string, metadata?: {
+        type?: MemoryType;
+        source?: "manual" | "auto-capture" | "import" | "api";
+        tags?: string[];
+        tool?: string;
+        sessionID?: string;
+        reasoning?: string;
+        captureTimestamp?: number;
+        displayName?: string;
+        userName?: string;
+        userEmail?: string;
+        projectPath?: string;
+        projectName?: string;
+        gitRepoUrl?: string;
+        [key: string]: unknown;
+    }): Promise<{
+        success: true;
+        id: string;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        id?: undefined;
+    }>;
+    deleteMemory(memoryId: string): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+    }>;
+    listMemories(containerTag: string, limit?: number): Promise<{
+        success: true;
+        memories: {
+            id: any;
+            summary: any;
+            createdAt: string;
+            metadata: any;
+            displayName: any;
+            userName: any;
+            userEmail: any;
+            projectPath: any;
+            projectName: any;
+            gitRepoUrl: any;
+        }[];
+        pagination: {
+            currentPage: number;
+            totalItems: number;
+            totalPages: number;
+        };
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        memories: never[];
+        pagination: {
+            currentPage: number;
+            totalItems: number;
+            totalPages: number;
+        };
+    }>;
+    searchMemoriesBySessionID(sessionID: string, containerTag: string, limit?: number): Promise<{
+        success: true;
+        results: {
+            id: any;
+            memory: any;
+            similarity: number;
+            tags: any;
+            metadata: any;
+            containerTag: any;
+            displayName: any;
+            userName: any;
+            userEmail: any;
+            projectPath: any;
+            projectName: any;
+            gitRepoUrl: any;
+            createdAt: any;
+        }[];
+        total: number;
+        timing: number;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        results: never[];
+        total: number;
+        timing: number;
+    }>;
+}
+export declare const memoryClient: LocalMemoryClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/services/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/services/client.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AA4CpD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,aAAa,CAAkB;;YAIzB,UAAU;IAiBlB,MAAM,CAAC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjE,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAIjC,SAAS,IAAI;QACX,WAAW,EAAE,OAAO,CAAC;QACrB,WAAW,EAAE,OAAO,CAAC;QACrB,KAAK,EAAE,OAAO,CAAC;KAChB;IAQD,KAAK,IAAI,IAAI;IAIP,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;;;;;;;;;;;;;IA6BlD,SAAS,CACb,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,UAAU,CAAC;QAClB,MAAM,CAAC,EAAE,QAAQ,GAAG,cAAc,GAAG,QAAQ,GAAG,KAAK,CAAC;QACtD,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB;;;;;;;;;IA+DG,YAAY,CAAC,QAAQ,EAAE,MAAM;;;;;;;IA2B7B,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,SAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuD7C,yBAAyB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4C5F;AAED,eAAO,MAAM,YAAY,mBAA0B,CAAC"}