@haisto/opencode-mem 2.14.3-beta.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const OpenCodeMemPlugin: Plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAmB/D,eAAO,MAAM,iBAAiB,EAAE,MA4hB/B,CAAC"}

package/dist/index.js

@@ -0,0 +1,486 @@
+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, initConfig } from "./config.js";
+import { log } from "./services/logger.js";
+import { getLanguageName } from "./services/language-detector.js";
+export const OpenCodeMemPlugin = async (ctx) => {
+    const { directory } = ctx;
+    initConfig(directory);
+    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()) {
+        // Fire-and-forget: warmup is slow (embedding model load + index rebuild).
+        // Awaiting it here serializes opencode's plugin loader and starves the TUI,
+        // which gave the symptom "opencode hangs ~70s then disconnects on startup".
+        (async () => {
+            try {
+                await memoryClient.warmup();
+                globalThis[GLOBAL_PLUGIN_WARMUP_KEY] = true;
+            }
+            catch (error) {
+                log("Plugin warmup failed", { error: String(error) });
+            }
+        })();
+    }
+    (async () => {
+        try {
+            const { setConnectedProviders, setV2Client, createV2Client } = await import("./services/ai/opencode-provider.js");
+            setV2Client(createV2Client(ctx.serverUrl));
+            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: `Your persistent brain. Before answering, always search(${getLanguageName(CONFIG.autoCaptureLanguage || "en")}) — you may have relevant knowledge. Save key info, decisions, and user preferences proactively. Search with technical keywords/tags (tags rank highest). Use 'profile' to store user preferences. Scope: project or all-projects.`,
+                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(),
+                    scope: tool.schema.enum(["project", "all-projects"]).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 or save an explicit preference (provide content to write)",
+                                            args: ["content?"],
+                                        },
+                                        { 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, args.scope ?? CONFIG.memory.defaultScope);
+                                if (!searchRes.success)
+                                    return JSON.stringify({ success: false, error: searchRes.error });
+                                return formatSearchResults(args.query, searchRes, args.limit);
+                            case "profile": {
+                                if (args.query) {
+                                    return JSON.stringify({
+                                        success: false,
+                                        error: "query is not valid for profile mode. Use content to write a preference or omit all args to read.",
+                                    });
+                                }
+                                const { userProfileManager } = await import("./services/user-profile/user-profile-manager.js");
+                                const userId = tags.user.userEmail || "unknown";
+                                // --- WRITE: explicit preference ---
+                                if (args.content !== undefined) {
+                                    const trimmed = args.content.trim();
+                                    if (!trimmed) {
+                                        return JSON.stringify({ success: false, error: "content must not be blank" });
+                                    }
+                                    if (!tags.user.userEmail) {
+                                        return JSON.stringify({
+                                            success: false,
+                                            error: "Cannot save profile preference because no user email could be resolved. Configure userEmailOverride or git user.email.",
+                                        });
+                                    }
+                                    const sanitizedContent = stripPrivateContent(trimmed);
+                                    const hasNonPrivateContent = sanitizedContent.replace(/\[REDACTED\]/g, "").trim().length > 0;
+                                    if (isFullyPrivate(trimmed) || !hasNonPrivateContent) {
+                                        return JSON.stringify({ success: false, error: "Private content blocked" });
+                                    }
+                                    const newPreference = {
+                                        category: "explicit",
+                                        description: sanitizedContent,
+                                        confidence: 1.0,
+                                        evidence: ["manual-write"],
+                                        lastUpdated: Date.now(),
+                                    };
+                                    const existingProfile = userProfileManager.getActiveProfile(userId);
+                                    if (existingProfile) {
+                                        const existingData = JSON.parse(existingProfile.profileData);
+                                        const mergedData = userProfileManager.mergeProfileData(existingData, {
+                                            preferences: [newPreference],
+                                        });
+                                        userProfileManager.updateProfile(existingProfile.id, mergedData, 0, `Explicit preference added: ${sanitizedContent.slice(0, 80)}`);
+                                        return JSON.stringify({
+                                            success: true,
+                                            message: "Preference saved to profile",
+                                        });
+                                    }
+                                    else {
+                                        userProfileManager.createProfile(userId, tags.user.displayName || userId, tags.user.userName || userId, tags.user.userEmail || userId, { preferences: [newPreference], patterns: [], workflows: [] }, 0);
+                                        return JSON.stringify({
+                                            success: true,
+                                            message: "Profile created with preference",
+                                        });
+                                    }
+                                }
+                                // --- READ: no content provided ---
+                                const profile = userProfileManager.getActiveProfile(userId);
+                                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, args.scope ?? CONFIG.memory.defaultScope);
+                                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() || !CONFIG.autoCaptureEnabled)
+                    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,9 @@
+declare const OpenCodeMemPlugin: import("@opencode-ai/plugin").Plugin;
+export declare const id: string;
+export { OpenCodeMemPlugin };
+declare const _default: {
+    id: string;
+    server: import("@opencode-ai/plugin").Plugin;
+};
+export default _default;
+//# 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":"AAEA,QAAA,MAAQ,iBAAiB,sCAA+B,CAAC;AAEzD,eAAO,MAAM,EAAE,QACqE,CAAC;AACrF,OAAO,EAAE,iBAAiB,EAAE,CAAC;;;;;AAC7B,wBAAwE"}

package/dist/plugin.js

@@ -0,0 +1,5 @@
+import pkg from "../package.json" with { type: "json" };
+const { OpenCodeMemPlugin } = await import("./index.js");
+export const id = typeof pkg.name === "string" && pkg.name.trim() ? pkg.name.trim() : "opencode-mem";
+export { OpenCodeMemPlugin };
+export default { id, server: 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,36 @@
+/**
+ * SDK-based structured output via opencode v2 session.prompt.
+ *
+ * Replaces the old auth.json/OAuth-juggling flow. Instead of forging requests
+ * to provider HTTP endpoints ourselves, we delegate to the running opencode
+ * server: it already owns the user's auth (any provider, including
+ * github-copilot personal/business), token refresh, and provider routing.
+ *
+ * Per call we create a transient session, prompt with a JSON schema, then
+ * delete the session so it does not pollute the user's TUI session list.
+ */
+import type { z } from "zod";
+import { type OpencodeClient } from "@opencode-ai/sdk/v2/client";
+export declare function setConnectedProviders(providers: string[]): void;
+export declare function isProviderConnected(providerName: string): boolean;
+export declare function setV2Client(client: OpencodeClient): void;
+export declare function getV2Client(): OpencodeClient | undefined;
+export declare function createV2Client(serverUrl: URL | string): OpencodeClient;
+export interface StructuredOutputOptions<T> {
+    client: OpencodeClient;
+    providerID: string;
+    modelID: string;
+    systemPrompt: string;
+    userPrompt: string;
+    schema: z.ZodType<T>;
+    directory?: string;
+    retryCount?: number;
+}
+/**
+ * Generate one structured-output completion via opencode's v2 API.
+ * Throws on: session.create failure, prompt failure, AssistantMessage.error
+ * (StructuredOutputError / ApiError / ...), missing `info.structured`,
+ * or final Zod validation failure.
+ */
+export declare function generateStructuredOutput<T>(opts: StructuredOutputOptions<T>): Promise<T>;
+//# 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":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAKvF,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAE/D;AAED,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAEjE;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAExD;AAED,wBAAgB,WAAW,IAAI,cAAc,GAAG,SAAS,CAExD;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,GAAG,GAAG,MAAM,GAAG,cAAc,CAGtE;AAED,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,MAAM,EAAE,cAAc,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAAC,CAAC,EAAE,IAAI,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAgF9F"}