opencode-mem 1.0.0

package/dist/services/auto-capture.js

@@ -0,0 +1,451 @@
+import { memoryClient } from "./client.js";
+import { getTags } from "./tags.js";
+import { log } from "./logger.js";
+import { CONFIG } from "../config.js";
+export class AutoCaptureService {
+    buffers = new Map();
+    capturing = new Set();
+    tokenThreshold;
+    minTokens;
+    enabled;
+    maxMemories;
+    constructor() {
+        this.tokenThreshold = CONFIG.autoCaptureTokenThreshold;
+        this.minTokens = CONFIG.autoCaptureMinTokens;
+        this.maxMemories = CONFIG.autoCaptureMaxMemories;
+        this.enabled =
+            CONFIG.autoCaptureEnabled &&
+                !!CONFIG.memoryModel &&
+                !!CONFIG.memoryApiUrl &&
+                !!CONFIG.memoryApiKey;
+        if (CONFIG.autoCaptureEnabled && !this.enabled) {
+            log("Auto-capture disabled: external API not configured (memoryModel, memoryApiUrl, memoryApiKey required)");
+        }
+        if (this.enabled && CONFIG.memoryApiUrl?.includes("ollama")) {
+            log("Warning: Ollama may not support tool calling. Auto-capture might fail.");
+        }
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    getDisabledReason() {
+        if (!CONFIG.autoCaptureEnabled)
+            return "Auto-capture disabled in config";
+        if (!CONFIG.memoryModel)
+            return "memoryModel not configured";
+        if (!CONFIG.memoryApiUrl)
+            return "memoryApiUrl not configured";
+        if (!CONFIG.memoryApiKey)
+            return "memoryApiKey not configured";
+        return null;
+    }
+    toggle() {
+        this.enabled = !this.enabled;
+        return this.enabled;
+    }
+    getOrCreateBuffer(sessionID) {
+        if (!this.buffers.has(sessionID)) {
+            this.buffers.set(sessionID, {
+                sessionID,
+                lastCaptureTokens: 0,
+                lastCaptureTime: Date.now(),
+                lastCapturedMessageIndex: -1,
+            });
+        }
+        return this.buffers.get(sessionID);
+    }
+    checkTokenThreshold(sessionID, totalTokens) {
+        if (!this.enabled)
+            return false;
+        if (this.capturing.has(sessionID))
+            return false;
+        const buffer = this.getOrCreateBuffer(sessionID);
+        if (totalTokens < this.minTokens)
+            return false;
+        const tokensSinceCapture = totalTokens - buffer.lastCaptureTokens;
+        if (tokensSinceCapture >= this.tokenThreshold) {
+            buffer.lastCaptureTokens = totalTokens;
+            return true;
+        }
+        return false;
+    }
+    getSystemPrompt(hasContext) {
+        const summaryGuidance = CONFIG.autoCaptureSummaryMaxLength > 0
+            ? `Keep summaries under ${CONFIG.autoCaptureSummaryMaxLength} characters.`
+            : "Extract key details and important information. Be concise but complete.";
+        const contextNote = hasContext
+            ? `\n\nIMPORTANT: Messages marked [CONTEXT] were already analyzed in previous capture. They are provided for context only. Focus your extraction on messages marked [NEW]. Do not duplicate memories from context messages.`
+            : "";
+        return `You are a memory extraction assistant analyzing PAST conversations between a USER and an AI ASSISTANT.
+
+IMPORTANT CONTEXT:
+- The conversation below has ALREADY HAPPENED
+- You are NOT the assistant in this conversation
+- Your job is to EXTRACT MEMORIES from this past conversation
+- DO NOT try to continue or respond to the conversation
+- DO NOT execute any tasks mentioned in the conversation${contextNote}
+
+EXTRACTION GUIDELINES:
+
+Categorize each memory by scope:
+- "user": Cross-project user behaviors, preferences, patterns, requests
+  Examples: "prefers TypeScript", "likes concise responses", "often asks about complexity analysis"
+- "project": Project-specific knowledge, decisions, architecture, context
+  Examples: "uses Bun runtime", "API at /api/v1", "working on opencode-mem plugin"
+
+Memory categorization:
+- Choose appropriate type: preference, architecture, workflow, bug-fix, configuration, pattern, request, context
+- Be specific and descriptive with categories
+- Focus on WHAT WAS DISCUSSED, not what should be done
+
+Summary guidelines:
+- ${summaryGuidance}
+- Only extract memories worth long-term retention
+- Be selective: quality over quantity
+- Each memory should be atomic and independent
+- Maximum ${this.maxMemories} memories per capture
+- Extract facts, decisions, and context - NOT tasks or actions
+
+Use the save_memories function to save extracteories.`;
+    }
+    markCapturing(sessionID) {
+        this.capturing.add(sessionID);
+    }
+    clearBuffer(sessionID) {
+        const buffer = this.buffers.get(sessionID);
+        if (buffer) {
+            this.buffers.set(sessionID, {
+                sessionID,
+                lastCaptureTokens: buffer.lastCaptureTokens,
+                lastCaptureTime: Date.now(),
+                lastCapturedMessageIndex: buffer.lastCapturedMessageIndex,
+            });
+        }
+        this.capturing.delete(sessionID);
+    }
+    getStats(sessionID) {
+        const buffer = this.buffers.get(sessionID);
+        if (!buffer)
+            return null;
+        return {
+            lastCaptureTokens: buffer.lastCaptureTokens,
+            timeSinceCapture: Date.now() - buffer.lastCaptureTime,
+        };
+    }
+    cleanup(sessionID) {
+        this.buffers.delete(sessionID);
+        this.capturing.delete(sessionID);
+    }
+}
+export async function performAutoCapture(ctx, service, sessionID, directory) {
+    try {
+        service.markCapturing(sessionID);
+        await ctx.client?.tui
+            .showToast({
+            body: {
+                title: "Auto-Capture",
+                message: "Analyzing conversation...",
+                variant: "info",
+                duration: 2000,
+            },
+        })
+            .catch(() => { });
+        if (!ctx.client) {
+            throw new Error("Client not available");
+        }
+        const response = await ctx.client.session.messages({
+            path: { id: sessionID },
+        });
+        if (!response.data) {
+            log("Auto-capture failed: no data in response", { sessionID });
+            service.clearBuffer(sessionID);
+            return;
+        }
+        const allMessages = response.data;
+        if (allMessages.length === 0) {
+            service.clearBuffer(sessionID);
+            return;
+        }
+        const buffer = service.getOrCreateBuffer(sessionID);
+        const lastIndex = buffer.lastCapturedMessageIndex;
+        if (allMessages.length <= lastIndex) {
+            buffer.lastCapturedMessageIndex = -1;
+            log("Auto-capture: message deletion detected, resetting index", { sessionID });
+        }
+        const contextWindow = CONFIG.autoCaptureContextWindow;
+        const startIndex = Math.max(0, lastIndex - contextWindow + 1);
+        const messagesToAnalyze = allMessages.slice(startIndex);
+        if (messagesToAnalyze.length === 0) {
+            service.clearBuffer(sessionID);
+            return;
+        }
+        const userMessages = messagesToAnalyze.filter((m) => m?.info?.role === "user");
+        const assistantMessages = messagesToAnalyze.filter((m) => m?.info?.role === "assistant");
+        if (userMessages.length === 0 || assistantMessages.length === 0) {
+            service.clearBuffer(sessionID);
+            return;
+        }
+        let hasCompletePair = false;
+        for (let i = 0; i < messagesToAnalyze.length - 1; i++) {
+            const current = messagesToAnalyze[i];
+            const next = messagesToAnalyze[i + 1];
+            if (current?.info?.role === "user" && next?.info?.role === "assistant") {
+                hasCompletePair = true;
+                break;
+            }
+        }
+        if (!hasCompletePair) {
+            service.clearBuffer(sessionID);
+            return;
+        }
+        const conversationParts = [];
+        for (let i = 0; i < messagesToAnalyze.length; i++) {
+            const msg = messagesToAnalyze[i];
+            if (!msg)
+                continue;
+            const globalIndex = startIndex + i;
+            const isNewMessage = globalIndex > lastIndex;
+            const role = msg.info?.role;
+            if (role !== "user" && role !== "assistant")
+                continue;
+            const roleLabel = role.toUpperCase();
+            const marker = isNewMessage ? "[NEW]" : "[CONTEXT]";
+            let content = "";
+            if (msg.parts && Array.isArray(msg.parts)) {
+                const textParts = msg.parts.filter((p) => p.type === "text" && p.text);
+                content = textParts.map((p) => p.text).join("\n");
+                const toolParts = msg.parts.filter((p) => p.type === "tool");
+                if (toolParts.length > 0) {
+                    content += "\n[Tools: " + toolParts.map((p) => p.name || "unknown").join(", ") + "]";
+                }
+            }
+            if (content) {
+                conversationParts.push(`${marker} ${roleLabel}: ${content}`);
+            }
+        }
+        if (conversationParts.length === 0) {
+            service.clearBuffer(sessionID);
+            return;
+        }
+        const conversationBody = conversationParts.join("\n\n");
+        const newMessageCount = allMessages.length - lastIndex - 1;
+        const contextMessageCount = messagesToAnalyze.length - newMessageCount;
+        const conversationText = `=== CONVERSATION TO ANALYZE ===
+
+Metadata:
+- Total messages in session: ${allMessages.length}
+- Messages in this analysis: ${messagesToAnalyze.length}
+- Context messages (already captured): ${contextMessageCount}
+- New messages (focus here): ${newMessageCount}
+${lastIndex >= 0 ? `- Previous capture ended at message index: ${lastIndex}` : "- This is the first capture for this session"}
+
+The following is a past conversation between a USER and an AI ASSISTANT.
+Extract meaningful memories from this conversation.
+
+${conversationBody}
+
+=== END OF CONVERSATION ===`;
+        const systemPrompt = service.getSystemPrompt(lastIndex >= 0);
+        const captureResponse = await summarizeWithAI(ctx, sessionID, systemPrompt, conversationText);
+        if (!captureResponse || !captureResponse.memories || captureResponse.memories.length === 0) {
+            service.clearBuffer(sessionID);
+            return;
+        }
+        const tags = getTags(directory);
+        const results = [];
+        for (const memory of captureResponse.memories.slice(0, CONFIG.autoCaptureMaxMemories)) {
+            if (!memory.summary || !memory.scope || !memory.type)
+                continue;
+            const tagInfo = memory.scope === "user" ? tags.user : tags.project;
+            const result = await memoryClient.addMemory(memory.summary, tagInfo.tag, {
+                type: memory.type,
+                source: "auto-capture",
+                sessionID,
+                reasoning: memory.reasoning,
+                captureTimestamp: Date.now(),
+                displayName: tagInfo.displayName,
+                userName: tagInfo.userName,
+                userEmail: tagInfo.userEmail,
+                projectPath: tagInfo.projectPath,
+                projectName: tagInfo.projectName,
+                gitRepoUrl: tagInfo.gitRepoUrl,
+            });
+            if (result.success) {
+                results.push({ scope: memory.scope, id: result.id });
+            }
+        }
+        if (results.length === 0) {
+            service.clearBuffer(sessionID);
+            return;
+        }
+        const userCount = results.filter((r) => r.scope === "user").length;
+        const projectCount = results.filter((r) => r.scope === "project").length;
+        await ctx.client?.tui
+            .showToast({
+            body: {
+                title: "Memory Captured",
+                message: `Saved ${userCount} user + ${projectCount} project memories`,
+                variant: "success",
+                duration: 3000,
+            },
+        })
+            .catch(() => { });
+        log("Auto-capture: success", {
+            sessionID,
+            userCount,
+            projectCount,
+            total: results.length,
+        });
+        buffer.lastCapturedMessageIndex = allMessages.length - 1;
+        service.clearBuffer(sessionID);
+    }
+    catch (error) {
+        log("Auto-capture error", { sessionID, error: String(error) });
+        await ctx.client?.tui
+            .showToast({
+            body: {
+                title: "Auto-Capture Failed",
+                message: String(error),
+                variant: "error",
+                duration: 5000,
+            },
+        })
+            .catch(() => { });
+        service.clearBuffer(sessionID);
+    }
+}
+async function summarizeWithAI(ctx, sessionID, systemPrompt, conversationPrompt) {
+    if (!ctx.client) {
+        throw new Error("Client not available");
+    }
+    if (!CONFIG.memoryModel || !CONFIG.memoryApiUrl || !CONFIG.memoryApiKey) {
+        throw new Error("External API not configured. Auto-capture requires memoryModel, memoryApiUrl, and memoryApiKey.");
+    }
+    return await callExternalAPIWithToolCalling(systemPrompt, conversationPrompt);
+}
+function createToolCallSchema() {
+    const summaryDescription = CONFIG.autoCaptureSummaryMaxLength > 0
+        ? `Memory summary (maximum ${CONFIG.autoCaptureSummaryMaxLength} characters). Focus on most critical information.`
+        : "Memory summary with key details and important information. Be concise but complete.";
+    return {
+        type: "function",
+        function: {
+            name: "save_memories",
+            description: "Save extracted memories from conversation analysis",
+            parameters: {
+                type: "object",
+                properties: {
+                    memories: {
+                        type: "array",
+                        description: "Array of memories extracted from the conversation",
+                        items: {
+                            type: "object",
+                            properties: {
+                                summary: {
+                                    type: "string",
+                                    description: summaryDescription,
+                                },
+                                scope: {
+                                    type: "string",
+                                    enum: ["user", "project"],
+                                    description: "user: cross-project user preferences/behaviors. project: project-specific knowledge/decisions.",
+                                },
+                                type: {
+                                    type: "string",
+                                    description: "Category of this memory (e.g., preference, architecture, workflow, bug-fix, configuration, pattern, etc). Choose the most appropriate category.",
+                                },
+                                reasoning: {
+                                    type: "string",
+                                    description: "Why this memory is important and worth retaining",
+                                },
+                            },
+                            required: ["summary", "scope", "type"],
+                        },
+                    },
+                },
+                required: ["memories"],
+            },
+        },
+    };
+}
+async function callExternalAPIWithToolCalling(systemPrompt, conversationPrompt) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 30000);
+    try {
+        const tools = [createToolCallSchema()];
+        const requestBody = {
+            model: CONFIG.memoryModel,
+            messages: [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: conversationPrompt },
+            ],
+            tools: tools,
+            tool_choice: { type: "function", name: "save_memories" },
+            temperature: 0.3,
+        };
+        const response = await fetch(`${CONFIG.memoryApiUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${CONFIG.memoryApiKey}`,
+            },
+            body: JSON.stringify(requestBody),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => response.statusText);
+            log("Auto-capture API error", {
+                status: response.status,
+                error: errorText,
+            });
+            throw new Error(`API error: ${response.status} - ${errorText}`);
+        }
+        const data = (await response.json());
+        if (!data.choices || !data.choices[0]) {
+            throw new Error("Invalid API response format");
+        }
+        const choice = data.choices[0];
+        if (!choice.message.tool_calls || choice.message.tool_calls.length === 0) {
+            log("Auto-capture: tool calling not used", {
+                finishReason: choice.finish_reason,
+            });
+            throw new Error("Tool calling not supported or not used by provider");
+        }
+        const toolCall = choice.message.tool_calls[0];
+        if (!toolCall || toolCall.function.name !== "save_memories") {
+            throw new Error("Invalid tool call response");
+        }
+        const parsed = JSON.parse(toolCall.function.arguments);
+        return validateCaptureResponse(parsed);
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new Error("API request timeout (30s)");
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function validateCaptureResponse(data) {
+    if (!data || typeof data !== "object") {
+        throw new Error("Response is not an object");
+    }
+    if (!Array.isArray(data.memories)) {
+        throw new Error("memories field is not an array");
+    }
+    const validMemories = data.memories.filter((m) => {
+        return (m &&
+            typeof m === "object" &&
+            typeof m.summary === "string" &&
+            m.summary.trim().length > 0 &&
+            (m.scope === "user" || m.scope === "project") &&
+            typeof m.type === "string" &&
+            m.type.trim().length > 0);
+    });
+    if (validMemories.length === 0) {
+        throw new Error("No valid memories in response");
+    }
+    return { memories: validMemories };
+}

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

@@ -0,0 +1,20 @@
+interface CleanupResult {
+    deletedCount: number;
+    userCount: number;
+    projectCount: 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":"AAMA,UAAU,aAAa;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB;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;IAqE1C,SAAS;;;;;;CAQV;AAED,eAAO,MAAM,cAAc,gBAAuB,CAAC"}

package/dist/services/cleanup-service.js

@@ -0,0 +1,88 @@
+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";
+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 {
+            log("Cleanup: starting", { retentionDays: CONFIG.autoCleanupRetentionDays });
+            const cutoffTime = Date.now() - CONFIG.autoCleanupRetentionDays * 24 * 60 * 60 * 1000;
+            const userShards = shardManager.getAllShards("user", "");
+            const projectShards = shardManager.getAllShards("project", "");
+            const allShards = [...userShards, ...projectShards];
+            let totalDeleted = 0;
+            let userDeleted = 0;
+            let projectDeleted = 0;
+            for (const shard of allShards) {
+                const db = connectionManager.getConnection(shard.dbPath);
+                const oldMemories = db
+                    .prepare(`
+          SELECT id, container_tag FROM memories 
+          WHERE updated_at < ? AND is_pinned = 0
+        `)
+                    .all(cutoffTime);
+                if (oldMemories.length === 0)
+                    continue;
+                for (const memory of oldMemories) {
+                    try {
+                        vectorSearch.deleteVector(db, memory.id);
+                        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) });
+                    }
+                }
+            }
+            log("Cleanup: completed", {
+                totalDeleted,
+                userDeleted,
+                projectDeleted,
+                cutoffTime: new Date(cutoffTime).toISOString(),
+            });
+            return {
+                deletedCount: totalDeleted,
+                userCount: userDeleted,
+                projectCount: projectDeleted,
+            };
+        }
+        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,104 @@
+import type { MemoryType } from "../types/index.js";
+import type { SearchResult } from "./sqlite/types.js";
+interface ProfileData {
+    static: string[];
+    dynamic: string[];
+}
+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;
+    };
+    searchMemories(query: string, containerTag: string): Promise<{
+        success: true;
+        results: SearchResult[];
+        total: number;
+        timing: number;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        results: never[];
+        total: number;
+        timing: number;
+    }>;
+    getProfile(containerTag: string, query?: string): Promise<{
+        success: true;
+        profile: ProfileData;
+        error?: undefined;
+    } | {
+        success: false;
+        error: string;
+        profile: null;
+    }>;
+    addMemory(content: string, containerTag: string, metadata?: {
+        type?: MemoryType;
+        source?: "manual" | "auto-capture" | "import" | "api";
+        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;
+        };
+    }>;
+}
+export declare const memoryClient: LocalMemoryClient;
+export {};
+//# 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;AACpD,OAAO,KAAK,EAAgB,YAAY,EAAE,MAAM,mBAAmB,CAAC;AA2CpE,UAAU,WAAW;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,aAAa,CAAkB;;YAIzB,UAAU;IAkBlB,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;IAQK,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;;;;;;;;;;;;;IA+BlD,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;;;;;;;;;IA2C/C,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,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;;;;;;;;;IAuDG,YAAY,CAAC,QAAQ,EAAE,MAAM;;;;;;;IA6B7B,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,SAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDpD;AAED,eAAO,MAAM,YAAY,mBAA0B,CAAC"}