@haisto/opencode-mem 2.14.3-beta.0

package/dist/services/jsonc.js

@@ -0,0 +1,76 @@
+/**
+ * Strips comments from JSONC content while respecting string boundaries.
+ * Handles // and /* comments, URLs in strings, and escaped quotes.
+ * Also removes trailing commas to support more relaxed JSONC format.
+ */
+export function stripJsoncComments(content) {
+    let result = "";
+    let i = 0;
+    let inString = false;
+    let inSingleLineComment = false;
+    let inMultiLineComment = false;
+    while (i < content.length) {
+        const char = content[i];
+        const nextChar = content[i + 1];
+        if (!inSingleLineComment && !inMultiLineComment) {
+            if (char === '"') {
+                // Count consecutive backslashes before this quote
+                let backslashCount = 0;
+                let j = i - 1;
+                while (j >= 0 && content[j] === "\\") {
+                    backslashCount++;
+                    j--;
+                }
+                // Quote is escaped only if preceded by ODD number of backslashes
+                // e.g., \" = escaped, \\" = not escaped (escaped backslash + quote)
+                if (backslashCount % 2 === 0) {
+                    inString = !inString;
+                }
+                result += char;
+                i++;
+                continue;
+            }
+        }
+        if (inString) {
+            result += char;
+            i++;
+            continue;
+        }
+        if (!inSingleLineComment && !inMultiLineComment) {
+            if (char === "/" && nextChar === "/") {
+                inSingleLineComment = true;
+                i += 2;
+                continue;
+            }
+            if (char === "/" && nextChar === "*") {
+                inMultiLineComment = true;
+                i += 2;
+                continue;
+            }
+        }
+        if (inSingleLineComment) {
+            if (char === "\n") {
+                inSingleLineComment = false;
+                result += char;
+            }
+            i++;
+            continue;
+        }
+        if (inMultiLineComment) {
+            if (char === "*" && nextChar === "/") {
+                inMultiLineComment = false;
+                i += 2;
+                continue;
+            }
+            if (char === "\n") {
+                result += char;
+            }
+            i++;
+            continue;
+        }
+        result += char;
+        i++;
+    }
+    // Remove trailing commas before } or ]
+    return result.replace(/,\s*([}\]])/g, "$1");
+}

package/dist/services/language-detector.d.ts

@@ -0,0 +1,3 @@
+export declare function detectLanguage(text: string): string;
+export declare function getLanguageName(code: string): string;
+//# sourceMappingURL=language-detector.d.ts.map

package/dist/services/language-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-detector.d.ts","sourceRoot":"","sources":["../../src/services/language-detector.ts"],"names":[],"mappings":"AAWA,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAiBnD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQpD"}

package/dist/services/language-detector.js

@@ -0,0 +1,33 @@
+import { franc } from "franc-min";
+import { iso6393, iso6393To1 } from "iso-639-3";
+// 3-letter codes without ISO 639-1 equivalents
+const FALLBACK_MAP = {
+    cmn: "zh", // Mandarin Chinese
+    yue: "zh", // Cantonese
+    arz: "ar", // Egyptian Arabic
+    hbs: "sr", // Serbo-Croatian
+};
+export function detectLanguage(text) {
+    if (!text || text.trim().length === 0) {
+        return "en";
+    }
+    const detected = franc(text, { minLength: 5 });
+    if (detected === "und") {
+        return "en";
+    }
+    // Try 2-letter mapping first
+    const twoLetter = iso6393To1[detected];
+    if (twoLetter)
+        return twoLetter;
+    // Fallback for 3-letter codes without 2-letter equivalent
+    return FALLBACK_MAP[detected] || "en";
+}
+export function getLanguageName(code) {
+    // Try 2-letter lookup first
+    let lang = iso6393.find((l) => l.iso6391 === code);
+    // Fallback to 3-letter lookup
+    if (!lang) {
+        lang = iso6393.find((l) => l.iso6393 === code);
+    }
+    return lang?.name || "English";
+}

package/dist/services/logger.d.ts

@@ -0,0 +1,11 @@
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error";
+export declare function setLogLevel(level: LogLevel): void;
+export declare function getLogLevel(): LogLevel;
+/** @deprecated Use logInfo/logWarn/logError/logDebug instead */
+export declare function log(message: string, data?: unknown): void;
+export declare function logTrace(message: string, data?: unknown): void;
+export declare function logDebug(message: string, data?: unknown): void;
+export declare function logInfo(message: string, data?: unknown): void;
+export declare function logWarn(message: string, data?: unknown): void;
+export declare function logError(message: string, data?: unknown): void;
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/services/logger.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAiBrE,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAEjD;AAED,wBAAgB,WAAW,IAAI,QAAQ,CAItC;AA6DD,gEAAgE;AAChE,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,QAElD;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,QAEvD;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,QAEvD;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,QAEtD;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,QAEtD;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,QAEvD"}

package/dist/services/logger.js

@@ -0,0 +1,97 @@
+import { appendFileSync, writeFileSync, existsSync, mkdirSync, statSync, renameSync, unlinkSync, } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const LOG_LEVEL_ORDER = {
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+};
+function getInitialLogLevel() {
+    if (process.env.OPENCODE_MEM_DEBUG)
+        return LOG_LEVEL_ORDER.debug;
+    return LOG_LEVEL_ORDER.info;
+}
+let currentLogLevel = getInitialLogLevel();
+export function setLogLevel(level) {
+    currentLogLevel = LOG_LEVEL_ORDER[level];
+}
+export function getLogLevel() {
+    return Object.entries(LOG_LEVEL_ORDER).find(([_, v]) => v === currentLogLevel)?.[0] || "info";
+}
+function getLogFilePath() {
+    return process.env.OPENCODE_MEM_LOG_FILE || join(homedir(), ".opencode-mem", "opencode-mem.log");
+}
+function getLogDirPath() {
+    const logFile = getLogFilePath();
+    const lastSlash = Math.max(logFile.lastIndexOf("/"), logFile.lastIndexOf("\\"));
+    return lastSlash === -1 ? "." : logFile.slice(0, lastSlash);
+}
+const MAX_LOG_SIZE = 5 * 1024 * 1024;
+const GLOBAL_LOGGER_KEY = Symbol.for("opencode-mem.logger.initialized");
+function localTimestamp() {
+    const d = new Date();
+    const pad = (n, len = 2) => String(n).padStart(len, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`;
+}
+function rotateLog() {
+    const logFile = getLogFilePath();
+    try {
+        if (!existsSync(logFile))
+            return;
+        const stats = statSync(logFile);
+        if (stats.size < MAX_LOG_SIZE)
+            return;
+        const oldLog = logFile + ".old";
+        if (existsSync(oldLog))
+            unlinkSync(oldLog);
+        renameSync(logFile, oldLog);
+    }
+    catch { }
+}
+function ensureLoggerInitialized() {
+    if (globalThis[GLOBAL_LOGGER_KEY])
+        return;
+    const logDir = getLogDirPath();
+    const logFile = getLogFilePath();
+    if (!existsSync(logDir)) {
+        mkdirSync(logDir, { recursive: true });
+    }
+    rotateLog();
+    writeFileSync(logFile, `\n--- Session started: ${localTimestamp()} ---\n`, {
+        flag: "a",
+    });
+    globalThis[GLOBAL_LOGGER_KEY] = true;
+}
+function writeLog(level, message, data) {
+    if (LOG_LEVEL_ORDER[level] < currentLogLevel)
+        return;
+    ensureLoggerInitialized();
+    const logFile = getLogFilePath();
+    const timestamp = localTimestamp();
+    const levelTag = level.toUpperCase().padEnd(5);
+    const line = data
+        ? `[${timestamp}] [${levelTag}] ${message}: ${JSON.stringify(data)}\n`
+        : `[${timestamp}] [${levelTag}] ${message}\n`;
+    appendFileSync(logFile, line);
+}
+/** @deprecated Use logInfo/logWarn/logError/logDebug instead */
+export function log(message, data) {
+    writeLog("info", message, data);
+}
+export function logTrace(message, data) {
+    writeLog("trace", message, data);
+}
+export function logDebug(message, data) {
+    writeLog("debug", message, data);
+}
+export function logInfo(message, data) {
+    writeLog("info", message, data);
+}
+export function logWarn(message, data) {
+    writeLog("warn", message, data);
+}
+export function logError(message, data) {
+    writeLog("error", message, data);
+}

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

@@ -0,0 +1,42 @@
+export interface DimensionMismatch {
+    needsMigration: boolean;
+    configDimensions: number;
+    configModel: string;
+    shardMismatches: Array<{
+        shardId: number;
+        dbPath: string;
+        storedDimensions: number;
+        storedModel: string;
+        vectorCount: number;
+    }>;
+}
+export interface MigrationProgress {
+    phase: "preparing" | "re-embedding" | "cleanup" | "complete";
+    processed: number;
+    total: number;
+    currentShard?: string;
+}
+export interface MigrationResult {
+    success: boolean;
+    strategy: "fresh-start" | "re-embed";
+    deletedShards: number;
+    reEmbeddedMemories: number;
+    duration: number;
+    error?: string;
+}
+export declare class MigrationService {
+    private isRunning;
+    private progressCallback?;
+    detectDimensionMismatch(): Promise<DimensionMismatch>;
+    migrateToNewModel(strategy: "fresh-start" | "re-embed", progressCallback?: (progress: MigrationProgress) => void): Promise<MigrationResult>;
+    private freshStartMigration;
+    private reEmbedMigration;
+    private reportProgress;
+    getStatus(): {
+        isRunning: boolean;
+        configModel: string;
+        configDimensions: number;
+    };
+}
+export declare const migrationService: MigrationService;
+//# sourceMappingURL=migration-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migration-service.d.ts","sourceRoot":"","sources":["../../src/services/migration-service.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,KAAK,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,WAAW,GAAG,cAAc,GAAG,SAAS,GAAG,UAAU,CAAC;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,aAAa,GAAG,UAAU,CAAC;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,gBAAgB,CAAC,CAAwC;IAE3D,uBAAuB,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAoDrD,iBAAiB,CACrB,QAAQ,EAAE,aAAa,GAAG,UAAU,EACpC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,IAAI,GACvD,OAAO,CAAC,eAAe,CAAC;YA2Cb,mBAAmB;YA8CnB,gBAAgB;IA+I9B,OAAO,CAAC,cAAc;IAMtB,SAAS;;;;;CAOV;AAED,eAAO,MAAM,gBAAgB,kBAAyB,CAAC"}

package/dist/services/migration-service.js

@@ -0,0 +1,250 @@
+import { shardManager } from "./sqlite/shard-manager.js";
+import { connectionManager } from "./sqlite/connection-manager.js";
+import { vectorSearch } from "./sqlite/vector-search.js";
+import { embeddingService } from "./embedding.js";
+import { CONFIG } from "../config.js";
+import { log } from "./logger.js";
+export class MigrationService {
+    isRunning = false;
+    progressCallback;
+    async detectDimensionMismatch() {
+        const userShards = shardManager.getAllShards("user", "");
+        const projectShards = shardManager.getAllShards("project", "");
+        const allShards = [...userShards, ...projectShards];
+        const mismatches = [];
+        for (const shard of allShards) {
+            try {
+                const db = connectionManager.getConnection(shard.dbPath);
+                const metadataResult = db
+                    .prepare(`
+          SELECT key, value FROM shard_metadata 
+          WHERE key IN ('embedding_dimensions', 'embedding_model')
+        `)
+                    .all();
+                const metadata = Object.fromEntries(metadataResult.map((row) => [row.key, row.value]));
+                const storedDimensions = parseInt(metadata.embedding_dimensions || "0");
+                const storedModel = metadata.embedding_model || "unknown";
+                if (storedDimensions !== CONFIG.embeddingDimensions) {
+                    const vectorCount = vectorSearch.countAllVectors(db);
+                    mismatches.push({
+                        shardId: shard.id,
+                        dbPath: shard.dbPath,
+                        storedDimensions,
+                        storedModel,
+                        vectorCount,
+                    });
+                }
+            }
+            catch (error) {
+                log("Migration: error checking shard", {
+                    shardId: shard.id,
+                    error: String(error),
+                });
+            }
+        }
+        return {
+            needsMigration: mismatches.length > 0,
+            configDimensions: CONFIG.embeddingDimensions,
+            configModel: CONFIG.embeddingModel,
+            shardMismatches: mismatches,
+        };
+    }
+    async migrateToNewModel(strategy, progressCallback) {
+        if (this.isRunning) {
+            throw new Error("Migration already running");
+        }
+        this.isRunning = true;
+        this.progressCallback = progressCallback;
+        const startTime = Date.now();
+        try {
+            const mismatch = await this.detectDimensionMismatch();
+            if (!mismatch.needsMigration) {
+                return {
+                    success: true,
+                    strategy,
+                    deletedShards: 0,
+                    reEmbeddedMemories: 0,
+                    duration: Date.now() - startTime,
+                };
+            }
+            if (strategy === "fresh-start") {
+                return await this.freshStartMigration(mismatch, startTime);
+            }
+            else {
+                return await this.reEmbedMigration(mismatch, startTime);
+            }
+        }
+        catch (error) {
+            log("Migration: failed", { error: String(error) });
+            return {
+                success: false,
+                strategy,
+                deletedShards: 0,
+                reEmbeddedMemories: 0,
+                duration: Date.now() - startTime,
+                error: String(error),
+            };
+        }
+        finally {
+            this.isRunning = false;
+            this.progressCallback = undefined;
+        }
+    }
+    async freshStartMigration(mismatch, startTime) {
+        this.reportProgress({
+            phase: "preparing",
+            processed: 0,
+            total: mismatch.shardMismatches.length,
+        });
+        let deletedShards = 0;
+        for (const [index, shardInfo] of mismatch.shardMismatches.entries()) {
+            try {
+                this.reportProgress({
+                    phase: "cleanup",
+                    processed: index,
+                    total: mismatch.shardMismatches.length,
+                    currentShard: String(shardInfo.shardId),
+                });
+                await shardManager.deleteShard(shardInfo.shardId);
+                deletedShards++;
+            }
+            catch (error) {
+                log("Migration: error deleting shard", {
+                    shardId: shardInfo.shardId,
+                    error: String(error),
+                });
+            }
+        }
+        this.reportProgress({
+            phase: "complete",
+            processed: mismatch.shardMismatches.length,
+            total: mismatch.shardMismatches.length,
+        });
+        return {
+            success: true,
+            strategy: "fresh-start",
+            deletedShards,
+            reEmbeddedMemories: 0,
+            duration: Date.now() - startTime,
+        };
+    }
+    async reEmbedMigration(mismatch, startTime) {
+        await embeddingService.warmup();
+        embeddingService.clearCache();
+        const totalMemories = mismatch.shardMismatches.reduce((sum, s) => sum + s.vectorCount, 0);
+        this.reportProgress({
+            phase: "preparing",
+            processed: 0,
+            total: totalMemories,
+        });
+        let reEmbeddedCount = 0;
+        let processedCount = 0;
+        for (const shardInfo of mismatch.shardMismatches) {
+            this.reportProgress({
+                phase: "re-embedding",
+                processed: processedCount,
+                total: totalMemories,
+                currentShard: String(shardInfo.shardId),
+            });
+            try {
+                const db = connectionManager.getConnection(shardInfo.dbPath);
+                const memories = vectorSearch.getAllMemories(db);
+                const tempMemories = [];
+                for (const memory of memories) {
+                    tempMemories.push({
+                        id: memory.id,
+                        content: memory.content,
+                        containerTag: memory.container_tag,
+                        type: memory.type,
+                        createdAt: memory.created_at,
+                        updatedAt: memory.updated_at,
+                        metadata: memory.metadata,
+                        displayName: memory.display_name,
+                        userName: memory.user_name,
+                        userEmail: memory.user_email,
+                        projectPath: memory.project_path,
+                        projectName: memory.project_name,
+                        gitRepoUrl: memory.git_repo_url,
+                        isPinned: memory.is_pinned || 0,
+                    });
+                }
+                await shardManager.deleteShard(shardInfo.shardId);
+                for (const memory of tempMemories) {
+                    try {
+                        const vector = await embeddingService.embedWithTimeout(memory.content);
+                        const scope = memory.containerTag.includes("_user_") ? "user" : "project";
+                        const hash = memory.containerTag.split("_").slice(2).join("_");
+                        const newShard = shardManager.getWriteShard(scope, hash);
+                        const newDb = connectionManager.getConnection(newShard.dbPath);
+                        await vectorSearch.insertVector(newDb, {
+                            id: memory.id,
+                            content: memory.content,
+                            vector,
+                            containerTag: memory.containerTag,
+                            type: memory.type || undefined,
+                            createdAt: memory.createdAt,
+                            updatedAt: memory.updatedAt,
+                            metadata: memory.metadata || undefined,
+                            displayName: memory.displayName || undefined,
+                            userName: memory.userName || undefined,
+                            userEmail: memory.userEmail || undefined,
+                            projectPath: memory.projectPath || undefined,
+                            projectName: memory.projectName || undefined,
+                            gitRepoUrl: memory.gitRepoUrl || undefined,
+                        }, newShard);
+                        if (memory.isPinned === 1) {
+                            vectorSearch.pinMemory(newDb, memory.id);
+                        }
+                        shardManager.incrementVectorCount(newShard.id);
+                        reEmbeddedCount++;
+                        processedCount++;
+                        this.reportProgress({
+                            phase: "re-embedding",
+                            processed: processedCount,
+                            total: totalMemories,
+                            currentShard: String(shardInfo.shardId),
+                        });
+                    }
+                    catch (error) {
+                        log("Migration: error re-embedding memory", {
+                            memoryId: memory.id,
+                            error: String(error),
+                        });
+                        processedCount++;
+                    }
+                }
+            }
+            catch (error) {
+                log("Migration: error processing shard", {
+                    shardId: shardInfo.shardId,
+                    error: String(error),
+                });
+            }
+        }
+        this.reportProgress({
+            phase: "complete",
+            processed: totalMemories,
+            total: totalMemories,
+        });
+        return {
+            success: true,
+            strategy: "re-embed",
+            deletedShards: mismatch.shardMismatches.length,
+            reEmbeddedMemories: reEmbeddedCount,
+            duration: Date.now() - startTime,
+        };
+    }
+    reportProgress(progress) {
+        if (this.progressCallback) {
+            this.progressCallback(progress);
+        }
+    }
+    getStatus() {
+        return {
+            isRunning: this.isRunning,
+            configModel: CONFIG.embeddingModel,
+            configDimensions: CONFIG.embeddingDimensions,
+        };
+    }
+}
+export const migrationService = new MigrationService();

package/dist/services/privacy.d.ts

@@ -0,0 +1,3 @@
+export declare function stripPrivateContent(content: string): string;
+export declare function isFullyPrivate(content: string): boolean;
+//# sourceMappingURL=privacy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"privacy.d.ts","sourceRoot":"","sources":["../../src/services/privacy.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGvD"}

package/dist/services/privacy.js

@@ -0,0 +1,7 @@
+export function stripPrivateContent(content) {
+    return content.replace(/<private>[\s\S]*?<\/private>/gi, "[REDACTED]");
+}
+export function isFullyPrivate(content) {
+    const stripped = stripPrivateContent(content).trim();
+    return stripped === "[REDACTED]" || stripped === "";
+}

package/dist/services/secret-resolver.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveSecretValue(value: string | undefined): string | undefined;
+//# sourceMappingURL=secret-resolver.d.ts.map

package/dist/services/secret-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-resolver.d.ts","sourceRoot":"","sources":["../../src/services/secret-resolver.ts"],"names":[],"mappings":"AAiCA,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAkChF"}

package/dist/services/secret-resolver.js

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+function expandPath(path) {
+    if (path.startsWith("~/")) {
+        return join(homedir(), path.slice(2));
+    }
+    if (path === "~") {
+        return homedir();
+    }
+    return path;
+}
+function checkFilePermissions(filePath) {
+    if (platform() === "win32") {
+        return;
+    }
+    try {
+        const stats = statSync(filePath);
+        const mode = stats.mode & 0o777;
+        if (mode > 0o600) {
+            console.warn(`Warning: Secret file ${filePath} has permissive permissions (${mode.toString(8)}). Recommend chmod 600.`);
+        }
+    }
+    catch (error) {
+        console.warn(`Warning: Could not check file permissions for ${filePath}`);
+    }
+}
+export function resolveSecretValue(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (value.startsWith("file://")) {
+        const filePath = expandPath(value.slice(7));
+        if (!existsSync(filePath)) {
+            throw new Error(`Secret file not found: ${filePath}`);
+        }
+        try {
+            checkFilePermissions(filePath);
+            const content = readFileSync(filePath, "utf-8");
+            return content.trim();
+        }
+        catch (error) {
+            throw new Error(`Failed to read secret file ${filePath}: ${error}`);
+        }
+    }
+    if (value.startsWith("env://")) {
+        const envVar = value.slice(6);
+        const envValue = process.env[envVar];
+        if (!envValue) {
+            throw new Error(`Environment variable not found: ${envVar}`);
+        }
+        return envValue;
+    }
+    return value;
+}

package/dist/services/sqlite/connection-manager.d.ts

@@ -0,0 +1,13 @@
+declare const Database: typeof import("bun:sqlite").Database;
+export declare class ConnectionManager {
+    private connections;
+    private initDatabase;
+    private migrateSchema;
+    getConnection(dbPath: string): typeof Database.prototype;
+    closeConnection(dbPath: string): void;
+    closeAll(): void;
+    checkpointAll(): void;
+}
+export declare const connectionManager: ConnectionManager;
+export {};
+//# sourceMappingURL=connection-manager.d.ts.map

package/dist/services/sqlite/connection-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-manager.d.ts","sourceRoot":"","sources":["../../../src/services/sqlite/connection-manager.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,QAAQ,sCAAgB,CAAC;AAE/B,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAAqD;IAExE,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,aAAa;IAarB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,QAAQ,CAAC,SAAS;IAiBxD,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IASrC,QAAQ,IAAI,IAAI;IAYhB,aAAa,IAAI,IAAI;CAStB;AAED,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}