@xiaoxiamimengfb/my-opencode-mem 2.12.0

package/dist/index.js

@@ -0,0 +1,427 @@
+import { tool } from "@opencode-ai/plugin";
+import { memoryClient } from "./services/client.js";
+import { formatContextForPrompt } from "./services/context.js";
+import { getTags } from "./services/tags.js";
+import { stripPrivateContent, isFullyPrivate } from "./services/privacy.js";
+import { performAutoCapture } from "./services/auto-capture.js";
+import { performUserProfileLearning } from "./services/user-memory-learning.js";
+import { userPromptManager } from "./services/user-prompt/user-prompt-manager.js";
+import { startWebServer, WebServer } from "./services/web-server.js";
+import { isConfigured, CONFIG } from "./config.js";
+import { log } from "./services/logger.js";
+import { getLanguageName } from "./services/language-detector.js";
+import { setStatePath, setConnectedProviders } from "./services/ai/opencode-provider.js";
+export const OpenCodeMemPlugin = async (ctx) => {
+    const { directory } = ctx;
+    const tags = getTags(directory);
+    let webServer = null;
+    let idleTimeout = null;
+    if (!isConfigured()) {
+    }
+    const GLOBAL_PLUGIN_WARMUP_KEY = Symbol.for("opencode-mem.plugin.warmedup");
+    if (!globalThis[GLOBAL_PLUGIN_WARMUP_KEY] && isConfigured()) {
+        try {
+            await memoryClient.warmup();
+            globalThis[GLOBAL_PLUGIN_WARMUP_KEY] = true;
+        }
+        catch (error) {
+            log("Plugin warmup failed", { error: String(error) });
+        }
+    }
+    // Wire opencode state path and provider list — fire-and-forget to avoid blocking init
+    // These calls can hang if opencode isn't fully bootstrapped yet
+    (async () => {
+        try {
+            const pathResult = await ctx.client.path.get();
+            if (pathResult.data?.state) {
+                setStatePath(pathResult.data.state);
+            }
+            const providerResult = await ctx.client.provider.list();
+            if (providerResult.data?.connected) {
+                setConnectedProviders(providerResult.data.connected);
+            }
+        }
+        catch (error) {
+            log("Failed to initialize opencode provider state", { error: String(error) });
+        }
+    })();
+    if (CONFIG.webServerEnabled) {
+        startWebServer({
+            port: CONFIG.webServerPort,
+            host: CONFIG.webServerHost,
+            enabled: CONFIG.webServerEnabled,
+        })
+            .then((server) => {
+            webServer = server;
+            const url = webServer.getUrl();
+            webServer.setOnTakeoverCallback(async () => {
+                if (ctx.client?.tui) {
+                    ctx.client.tui
+                        .showToast({
+                        body: {
+                            title: "Memory Explorer",
+                            message: "Took over web server ownership",
+                            variant: "success",
+                            duration: 3000,
+                        },
+                    })
+                        .catch(() => { });
+                }
+            });
+            if (webServer.isServerOwner()) {
+                if (ctx.client?.tui) {
+                    ctx.client.tui
+                        .showToast({
+                        body: {
+                            title: "Memory Explorer",
+                            message: `Web UI started at ${url}`,
+                            variant: "success",
+                            duration: 5000,
+                        },
+                    })
+                        .catch(() => { });
+                }
+            }
+            else {
+                if (ctx.client?.tui) {
+                    ctx.client.tui
+                        .showToast({
+                        body: {
+                            title: "Memory Explorer",
+                            message: `Web UI available at ${url}`,
+                            variant: "info",
+                            duration: 3000,
+                        },
+                    })
+                        .catch(() => { });
+                }
+            }
+        })
+            .catch((error) => {
+            log("Web server failed to start", { error: String(error) });
+            if (ctx.client?.tui) {
+                ctx.client.tui
+                    .showToast({
+                    body: {
+                        title: "Memory Explorer Error",
+                        message: `Failed to start: ${String(error)}`,
+                        variant: "error",
+                        duration: 5000,
+                    },
+                })
+                    .catch(() => { });
+            }
+        });
+    }
+    const shutdownHandler = async () => {
+        try {
+            if (webServer) {
+                await webServer.stop();
+            }
+            memoryClient.close();
+            process.exit(0);
+        }
+        catch (error) {
+            log("Shutdown error", { error: String(error) });
+            process.exit(1);
+        }
+    };
+    process.on("SIGINT", shutdownHandler);
+    process.on("SIGTERM", shutdownHandler);
+    return {
+        "chat.message": async (input, output) => {
+            if (!isConfigured() || !CONFIG.chatMessage.enabled)
+                return;
+            try {
+                const textParts = output.parts.filter((p) => p.type === "text");
+                if (textParts.length === 0)
+                    return;
+                const userMessage = textParts.map((p) => p.text).join("\n");
+                if (!userMessage.trim())
+                    return;
+                userPromptManager.savePrompt(input.sessionID, output.message.id, directory, userMessage);
+                const messagesResponse = await ctx.client.session.messages({
+                    path: { id: input.sessionID },
+                });
+                const messages = messagesResponse.data || [];
+                const hasNonSyntheticUserMessages = messages.some((m) => m.info.role === "user" &&
+                    !m.parts.every((p) => p.type !== "text" || p.synthetic === true));
+                const lastMessage = messages.length > 0 ? messages[messages.length - 1] : null;
+                const isAfterCompaction = lastMessage?.info?.summary === true;
+                const shouldInject = CONFIG.chatMessage.injectOn === "always" ||
+                    !hasNonSyntheticUserMessages ||
+                    (isAfterCompaction &&
+                        messages.filter((m) => m.info.role === "user" &&
+                            !m.parts.every((p) => p.type !== "text" || p.synthetic === true)).length === 1);
+                if (!shouldInject)
+                    return;
+                const listResult = await memoryClient.listMemories(tags.project.tag, CONFIG.chatMessage.maxMemories);
+                let memories = listResult.success ? listResult.memories : [];
+                if (CONFIG.chatMessage.excludeCurrentSession) {
+                    memories = memories.filter((m) => m.metadata?.sessionID !== input.sessionID);
+                }
+                if (CONFIG.chatMessage.maxAgeDays) {
+                    const cutoffDate = Date.now() - CONFIG.chatMessage.maxAgeDays * 86400000;
+                    memories = memories.filter((m) => new Date(m.createdAt).getTime() > cutoffDate);
+                }
+                if (memories.length === 0)
+                    return;
+                const projectMemories = {
+                    results: memories.map((m) => ({
+                        similarity: 1.0,
+                        memory: m.summary,
+                    })),
+                    total: memories.length,
+                    timing: 0,
+                };
+                const userId = tags.user.userEmail || null;
+                const memoryContext = formatContextForPrompt(userId, projectMemories);
+                if (memoryContext) {
+                    const contextPart = {
+                        id: `prt-memory-context-${Date.now()}`,
+                        sessionID: input.sessionID,
+                        messageID: output.message.id,
+                        type: "text",
+                        text: memoryContext,
+                        synthetic: true,
+                    };
+                    output.parts.unshift(contextPart);
+                }
+            }
+            catch (error) {
+                log("chat.message: ERROR", { error: String(error) });
+                if (ctx.client?.tui && CONFIG.showErrorToasts) {
+                    await ctx.client.tui
+                        .showToast({
+                        body: {
+                            title: "Memory System Error",
+                            message: String(error),
+                            variant: "error",
+                            duration: 5000,
+                        },
+                    })
+                        .catch(() => { });
+                }
+            }
+        },
+        tool: {
+            memory: tool({
+                description: `Manage and query project memory (MATCH USER LANGUAGE: ${getLanguageName(CONFIG.autoCaptureLanguage || "en")}). Use 'search' with technical keywords/tags, 'add' to store knowledge, 'profile' for preferences.`,
+                args: {
+                    mode: tool.schema.enum(["add", "search", "profile", "list", "forget", "help"]).optional(),
+                    content: tool.schema.string().optional(),
+                    query: tool.schema.string().optional(),
+                    tags: tool.schema.string().optional(),
+                    type: tool.schema.string().optional(),
+                    memoryId: tool.schema.string().optional(),
+                    limit: tool.schema.number().optional(),
+                },
+                async execute(args, toolCtx) {
+                    if (!isConfigured()) {
+                        return JSON.stringify({
+                            success: false,
+                            error: "Memory system not configured properly.",
+                        });
+                    }
+                    const needsWarmup = !(await memoryClient.isReady());
+                    if (needsWarmup) {
+                        return JSON.stringify({ success: false, error: "Memory system is initializing." });
+                    }
+                    const mode = args.mode || "help";
+                    const langName = getLanguageName(CONFIG.autoCaptureLanguage || "en");
+                    try {
+                        switch (mode) {
+                            case "help":
+                                return JSON.stringify({
+                                    success: true,
+                                    message: "Memory System Usage Guide",
+                                    commands: [
+                                        {
+                                            command: "add",
+                                            description: `Store new memory (MATCH USER LANGUAGE: ${langName})`,
+                                            args: ["content", "type?", "tags?"],
+                                        },
+                                        {
+                                            command: "search",
+                                            description: `Search memories via keywords (MATCH USER LANGUAGE: ${langName})`,
+                                            args: ["query"],
+                                        },
+                                        { command: "profile", description: "View user profile", args: [] },
+                                        { command: "list", description: "List recent memories", args: ["limit?"] },
+                                        { command: "forget", description: "Remove memory", args: ["memoryId"] },
+                                    ],
+                                    tagGuidance: "Use technical keywords for search. Tags rank highest.",
+                                });
+                            case "add":
+                                if (!args.content)
+                                    return JSON.stringify({ success: false, error: "content required" });
+                                const sanitizedContent = stripPrivateContent(args.content);
+                                if (isFullyPrivate(args.content))
+                                    return JSON.stringify({ success: false, error: "Private content blocked" });
+                                const tagInfo = tags.project;
+                                const parsedTags = args.tags
+                                    ? args.tags.split(",").map((t) => t.trim().toLowerCase())
+                                    : undefined;
+                                const result = await memoryClient.addMemory(sanitizedContent, tagInfo.tag, {
+                                    type: args.type,
+                                    tags: parsedTags,
+                                    displayName: tagInfo.displayName,
+                                    userName: tagInfo.userName,
+                                    userEmail: tagInfo.userEmail,
+                                    projectPath: tagInfo.projectPath,
+                                    projectName: tagInfo.projectName,
+                                    gitRepoUrl: tagInfo.gitRepoUrl,
+                                });
+                                return JSON.stringify({
+                                    success: result.success,
+                                    message: `Memory added`,
+                                    id: result.id,
+                                    tags: parsedTags,
+                                });
+                            case "search":
+                                if (!args.query)
+                                    return JSON.stringify({ success: false, error: "query required" });
+                                const searchRes = await memoryClient.searchMemories(args.query, tags.project.tag);
+                                if (!searchRes.success)
+                                    return JSON.stringify({ success: false, error: searchRes.error });
+                                return formatSearchResults(args.query, searchRes, args.limit);
+                            case "profile":
+                                const { userProfileManager } = await import("./services/user-profile/user-profile-manager.js");
+                                const profile = userProfileManager.getActiveProfile(tags.user.userEmail || "unknown");
+                                if (!profile)
+                                    return JSON.stringify({ success: true, profile: null });
+                                const pData = JSON.parse(profile.profileData);
+                                return JSON.stringify({
+                                    success: true,
+                                    profile: {
+                                        ...pData,
+                                        version: profile.version,
+                                        lastAnalyzed: profile.lastAnalyzedAt,
+                                    },
+                                });
+                            case "list":
+                                const listRes = await memoryClient.listMemories(tags.project.tag, args.limit || 20);
+                                if (!listRes.success)
+                                    return JSON.stringify({ success: false, error: listRes.error });
+                                return JSON.stringify({
+                                    success: true,
+                                    count: listRes.memories?.length,
+                                    memories: listRes.memories?.map((m) => ({
+                                        id: m.id,
+                                        content: m.summary,
+                                        createdAt: m.createdAt,
+                                    })),
+                                });
+                            case "forget":
+                                if (!args.memoryId)
+                                    return JSON.stringify({ success: false, error: "memoryId required" });
+                                const delRes = await memoryClient.deleteMemory(args.memoryId);
+                                return JSON.stringify({ success: delRes.success, message: `Memory removed` });
+                            default:
+                                return JSON.stringify({ success: false, error: `Unknown mode: ${mode}` });
+                        }
+                    }
+                    catch (error) {
+                        return JSON.stringify({ success: false, error: String(error) });
+                    }
+                },
+            }),
+        },
+        event: async (input) => {
+            const event = input.event;
+            if (event.type === "session.idle") {
+                if (!isConfigured())
+                    return;
+                const sessionID = event.properties?.sessionID;
+                if (!sessionID)
+                    return;
+                if (idleTimeout)
+                    clearTimeout(idleTimeout);
+                idleTimeout = setTimeout(async () => {
+                    try {
+                        await performAutoCapture(ctx, sessionID, directory);
+                        if (webServer?.isServerOwner()) {
+                            await performUserProfileLearning(ctx, directory);
+                            const { cleanupService } = await import("./services/cleanup-service.js");
+                            if (await cleanupService.shouldRunCleanup())
+                                await cleanupService.runCleanup();
+                            const { connectionManager } = await import("./services/sqlite/connection-manager.js");
+                            connectionManager.checkpointAll();
+                        }
+                    }
+                    catch (error) {
+                        log("Idle processing error", { error: String(error) });
+                    }
+                    finally {
+                        idleTimeout = null;
+                    }
+                }, 10000);
+            }
+            if (event.type === "session.compacted") {
+                if (!isConfigured() || !CONFIG.compaction.enabled)
+                    return;
+                const sessionID = event.properties?.sessionID;
+                if (!sessionID)
+                    return;
+                try {
+                    const tags = getTags(directory);
+                    const memoriesResult = await memoryClient.searchMemoriesBySessionID(sessionID, tags.project.tag, CONFIG.compaction.memoryLimit);
+                    if (!memoriesResult.success || memoriesResult.results.length === 0) {
+                        return;
+                    }
+                    const memoryContext = formatMemoriesForCompaction(memoriesResult.results);
+                    await ctx.client.session.prompt({
+                        path: { id: sessionID },
+                        body: {
+                            parts: [{ id: `prt-compaction-${Date.now()}`, type: "text", text: memoryContext }],
+                            noReply: true,
+                        },
+                    });
+                    if (ctx.client?.tui) {
+                        await ctx.client.tui
+                            .showToast({
+                            body: {
+                                title: "Memory Restored",
+                                message: `${memoriesResult.results.length} memories injected after compaction`,
+                                variant: "success",
+                                duration: 3000,
+                            },
+                        })
+                            .catch(() => { });
+                    }
+                    log("Compaction memory injected", {
+                        sessionID,
+                        count: memoriesResult.results.length,
+                    });
+                }
+                catch (error) {
+                    log("Compaction handler error", { error: String(error) });
+                }
+            }
+        },
+    };
+};
+function formatSearchResults(query, results, limit) {
+    const memoryResults = results.results || [];
+    return JSON.stringify({
+        success: true,
+        query,
+        count: memoryResults.length,
+        results: memoryResults.slice(0, limit || 10).map((r) => ({
+            id: r.id,
+            content: r.memory || r.chunk,
+            similarity: Math.round(r.similarity * 100),
+        })),
+    });
+}
+function formatMemoriesForCompaction(memories) {
+    let output = `## Restored Session Memory\n\n`;
+    memories.forEach((m, i) => {
+        output += `### Memory ${i + 1}\n`;
+        output += `${m.memory}\n\n`;
+        if (m.tags && m.tags.length > 0) {
+            output += `Tags: ${m.tags.join(", ")}\n\n`;
+        }
+    });
+    return output;
+}

package/dist/plugin.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+declare const OpenCodeMemPlugin: import("@opencode-ai/plugin").Plugin;
+export { OpenCodeMemPlugin };
+export default OpenCodeMemPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":";AACA,QAAA,MAAQ,iBAAiB,sCAA+B,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAC7B,eAAe,iBAAiB,CAAC"}

package/dist/plugin.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+const { OpenCodeMemPlugin } = await import("./index.js");
+export { OpenCodeMemPlugin };
+export default OpenCodeMemPlugin;

package/dist/services/ai/ai-provider-factory.d.ts

@@ -0,0 +1,8 @@
+import { BaseAIProvider, type ProviderConfig } from "./providers/base-provider.js";
+import type { AIProviderType } from "./session/session-types.js";
+export declare class AIProviderFactory {
+    static createProvider(providerType: AIProviderType, config: ProviderConfig): BaseAIProvider;
+    static getSupportedProviders(): AIProviderType[];
+    static cleanupExpiredSessions(): number;
+}
+//# sourceMappingURL=ai-provider-factory.d.ts.map

package/dist/services/ai/ai-provider-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-provider-factory.d.ts","sourceRoot":"","sources":["../../../src/services/ai/ai-provider-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAMnF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEjE,qBAAa,iBAAiB;IAC5B,MAAM,CAAC,cAAc,CAAC,YAAY,EAAE,cAAc,EAAE,MAAM,EAAE,cAAc,GAAG,cAAc;IAmB3F,MAAM,CAAC,qBAAqB,IAAI,cAAc,EAAE;IAIhD,MAAM,CAAC,sBAAsB,IAAI,MAAM;CAGxC"}

package/dist/services/ai/ai-provider-factory.js

@@ -0,0 +1,28 @@
+import { BaseAIProvider } from "./providers/base-provider.js";
+import { OpenAIChatCompletionProvider } from "./providers/openai-chat-completion.js";
+import { OpenAIResponsesProvider } from "./providers/openai-responses.js";
+import { AnthropicMessagesProvider } from "./providers/anthropic-messages.js";
+import { GoogleGeminiProvider } from "./providers/google-gemini.js";
+import { aiSessionManager } from "./session/ai-session-manager.js";
+export class AIProviderFactory {
+    static createProvider(providerType, config) {
+        switch (providerType) {
+            case "openai-chat":
+                return new OpenAIChatCompletionProvider(config, aiSessionManager);
+            case "openai-responses":
+                return new OpenAIResponsesProvider(config, aiSessionManager);
+            case "anthropic":
+                return new AnthropicMessagesProvider(config, aiSessionManager);
+            case "google-gemini":
+                return new GoogleGeminiProvider(config, aiSessionManager);
+            default:
+                throw new Error(`Unknown provider type: ${providerType}`);
+        }
+    }
+    static getSupportedProviders() {
+        return ["openai-chat", "openai-responses", "anthropic", "google-gemini"];
+    }
+    static cleanupExpiredSessions() {
+        return aiSessionManager.cleanupExpiredSessions();
+    }
+}

package/dist/services/ai/opencode-provider.d.ts

@@ -0,0 +1,30 @@
+import type { ZodType } from "zod";
+type OAuthAuth = {
+    type: "oauth";
+    refresh: string;
+    access: string;
+    expires: number;
+};
+type ApiAuth = {
+    type: "api";
+    key: string;
+};
+type Auth = OAuthAuth | ApiAuth;
+export declare function setStatePath(path: string): void;
+export declare function getStatePath(): string;
+export declare function setConnectedProviders(providers: string[]): void;
+export declare function isProviderConnected(providerName: string): boolean;
+export declare function readOpencodeAuth(statePath: string, providerName: string): Auth;
+export declare function createOAuthFetch(statePath: string, providerName: string): (input: string | Request | URL, init?: RequestInit) => Promise<Response>;
+export declare function createOpencodeAIProvider(providerName: string, auth: Auth, statePath?: string): import("vercel-minimax-ai-provider").MinimaxOpenAIProvider;
+export declare function generateStructuredOutput<T>(options: {
+    providerName: string;
+    modelId: string;
+    statePath: string;
+    systemPrompt: string;
+    userPrompt: string;
+    schema: ZodType<T>;
+    temperature?: number;
+}): Promise<T>;
+export {};
+//# sourceMappingURL=opencode-provider.d.ts.map

package/dist/services/ai/opencode-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode-provider.d.ts","sourceRoot":"","sources":["../../../src/services/ai/opencode-provider.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,KAAK,SAAS,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AACrF,KAAK,OAAO,GAAG;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAC5C,KAAK,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC;AAMhC,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED,wBAAgB,YAAY,IAAI,MAAM,CAKrC;AAeD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAa/D;AAED,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CA2BjE;AAkBD,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAyC9E;AAQD,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAkJ1E;AAGD,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,MAAM,8DAyC5F;AAGD,wBAAsB,wBAAwB,CAAC,CAAC,EAAE,OAAO,EAAE;IACzD,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC,CAAC,CAAC,CAWb"}