opencode-mem 1.0.0

package/dist/services/sqlite-client.js

@@ -0,0 +1,284 @@
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG } from "../config.js";
+import { log } from "./logger.js";
+export class SQLiteMemoryClient {
+    db = null;
+    embedder;
+    isInitialized = false;
+    constructor(embedder) {
+        this.embedder = embedder;
+    }
+    initializeDatabase() {
+        if (!existsSync(CONFIG.storagePath)) {
+            mkdirSync(CONFIG.storagePath, { recursive: true });
+        }
+        const dbPath = join(CONFIG.storagePath, "memories.db");
+        this.db = new Database(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("synchronous = NORMAL");
+        this.db.pragma("cache_size = -64000");
+        this.db.pragma("temp_store = MEMORY");
+        sqliteVec.load(this.db);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        content TEXT NOT NULL,
+        vector BLOB NOT NULL,
+        containerTag TEXT NOT NULL,
+        type TEXT,
+        createdAt INTEGER NOT NULL,
+        updatedAt INTEGER NOT NULL,
+        metadata TEXT,
+        displayName TEXT,
+        userName TEXT,
+        userEmail TEXT,
+        projectPath TEXT,
+        projectName TEXT,
+        gitRepoUrl TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_containerTag ON memories(containerTag);
+      CREATE INDEX IF NOT EXISTS idx_createdAt ON memories(createdAt DESC);
+      CREATE INDEX IF NOT EXISTS idx_type ON memories(type);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0(
+        id TEXT PRIMARY KEY,
+        embedding FLOAT[384]
+      );
+    `);
+        log("SQLite database initialized", { path: dbPath });
+    }
+    async warmup(progressCallback) {
+        if (this.isInitialized)
+            return;
+        await this.embedder.warmup(progressCallback);
+        this.initializeDatabase();
+        this.isInitialized = true;
+        log("SQLite memory client ready");
+    }
+    async isReady() {
+        return this.isInitialized && this.embedder.isWarmedUp;
+    }
+    getStatus() {
+        return {
+            dbConnected: this.db !== null,
+            modelLoaded: this.embedder.isWarmedUp,
+            ready: this.isInitialized && this.embedder.isWarmedUp,
+        };
+    }
+    async addMemory(content, containerTag, metadata) {
+        log("addMemory: start", { containerTag, contentLength: content.length });
+        try {
+            if (!this.db)
+                throw new Error("Database not initialized");
+            const vector = await this.embedder.embed(content);
+            const vectorBuffer = Buffer.from(new Float32Array(vector).buffer);
+            const id = `mem_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+            const now = Date.now();
+            const record = {
+                id,
+                content,
+                containerTag,
+                type: metadata?.type,
+                createdAt: now,
+                updatedAt: now,
+                metadata: metadata ? JSON.stringify(metadata) : undefined,
+                displayName: metadata?.displayName,
+                userName: metadata?.userName,
+                userEmail: metadata?.userEmail,
+                projectPath: metadata?.projectPath,
+                projectName: metadata?.projectName,
+                gitRepoUrl: metadata?.gitRepoUrl,
+            };
+            const insertMemory = this.db.prepare(`
+        INSERT INTO memories (
+          id, content, vector, containerTag, type, createdAt, updatedAt,
+          metadata, displayName, userName, userEmail, projectPath, projectName, gitRepoUrl
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+            const insertVec = this.db.prepare(`
+        INSERT INTO vec_memories (id, embedding) VALUES (?, ?)
+      `);
+            this.db.transaction(() => {
+                insertMemory.run(record.id, record.content, vectorBuffer, record.containerTag, record.type, record.createdAt, record.updatedAt, record.metadata, record.displayName, record.userName, record.userEmail, record.projectPath, record.projectName, record.gitRepoUrl);
+                insertVec.run(record.id, vectorBuffer);
+            })();
+            log("addMemory: success", { id });
+            return { success: true, id };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log("addMemory: error", { error: errorMessage });
+            return { success: false, error: errorMessage };
+        }
+    }
+    async searchMemories(query, containerTag) {
+        log("searchMemories: start", { containerTag });
+        try {
+            if (!this.db)
+                throw new Error("Database not initialized");
+            const queryVector = await this.embedder.embed(query);
+            const queryBuffer = Buffer.from(new Float32Array(queryVector).buffer);
+            const stmt = this.db.prepare(`
+        SELECT 
+          m.id, m.content, m.metadata, m.displayName, m.userName, m.userEmail,
+          m.projectPath, m.projectName, m.gitRepoUrl,
+          vec_distance_L2(v.embedding, ?) as distance
+        FROM memories m
+        JOIN vec_memories v ON m.id = v.id
+        WHERE m.containerTag = ?
+        ORDER BY distance ASC
+        LIMIT ?
+      `);
+            const rows = stmt.all(queryBuffer, containerTag, CONFIG.maxMemories * 2);
+            const results = rows
+                .map((r) => ({
+                id: r.id,
+                memory: r.content,
+                similarity: 1 / (1 + r.distance),
+                metadata: r.metadata ? JSON.parse(r.metadata) : undefined,
+                displayName: r.displayName,
+                userName: r.userName,
+                userEmail: r.userEmail,
+                projectPath: r.projectPath,
+                projectName: r.projectName,
+                gitRepoUrl: r.gitRepoUrl,
+            }))
+                .filter((r) => r.similarity >= CONFIG.similarityThreshold);
+            log("searchMemories: success", { count: results.length });
+            return {
+                success: true,
+                results,
+                total: results.length,
+                timing: 0,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log("searchMemories: error", { error: errorMessage });
+            return {
+                success: false,
+                error: errorMessage,
+                results: [],
+                total: 0,
+                timing: 0,
+            };
+        }
+    }
+    async getProfile(containerTag, query) {
+        log("getProfile: start", { containerTag });
+        try {
+            if (!this.db)
+                throw new Error("Database not initialized");
+            const stmt = this.db.prepare(`
+        SELECT content, type
+        FROM memories
+        WHERE containerTag = ?
+        ORDER BY createdAt DESC
+        LIMIT ?
+      `);
+            const rows = stmt.all(containerTag, CONFIG.maxProfileItems * 2);
+            const staticFacts = [];
+            const dynamicFacts = [];
+            for (const r of rows) {
+                if (r.type === "preference") {
+                    staticFacts.push(r.content);
+                }
+                else {
+                    dynamicFacts.push(r.content);
+                }
+            }
+            const profile = {
+                static: staticFacts.slice(0, CONFIG.maxProfileItems),
+                dynamic: dynamicFacts.slice(0, CONFIG.maxProfileItems),
+            };
+            log("getProfile: success");
+            return { success: true, profile };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log("getProfile: error", { error: errorMessage });
+            return { success: false, error: errorMessage, profile: null };
+        }
+    }
+    async listMemories(containerTag, limit = 20) {
+        log("listMemories: start", { containerTag, limit });
+        try {
+            if (!this.db)
+                throw new Error("Database not initialized");
+            const stmt = this.db.prepare(`
+        SELECT * FROM memories
+        WHERE containerTag = ?
+        ORDER BY createdAt DESC
+        LIMIT ?
+      `);
+            const rows = stmt.all(containerTag, limit);
+            const memories = rows.map((r) => ({
+                id: r.id,
+                summary: r.content,
+                createdAt: new Date(r.createdAt).toISOString(),
+                metadata: r.metadata ? JSON.parse(r.metadata) : undefined,
+                displayName: r.displayName,
+                userName: r.userName,
+                userEmail: r.userEmail,
+                projectPath: r.projectPath,
+                projectName: r.projectName,
+                gitRepoUrl: r.gitRepoUrl,
+            }));
+            log("listMemories: success", { count: memories.length });
+            return {
+                success: true,
+                memories,
+                pagination: { currentPage: 1, totalItems: memories.length, totalPages: 1 },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log("listMemories: error", { error: errorMessage });
+            return {
+                success: false,
+                error: errorMessage,
+                memories: [],
+                pagination: { currentPage: 1, totalItems: 0, totalPages: 0 },
+            };
+        }
+    }
+    async deleteMemory(memoryId) {
+        log("deleteMemory: start", { memoryId });
+        try {
+            if (!this.db)
+                throw new Error("Database not initialized");
+            const deleteMemory = this.db.prepare("DELETE FROM memories WHERE id = ?");
+            const deleteVec = this.db.prepare("DELETE FROM vec_memories WHERE id = ?");
+            const result = this.db.transaction(() => {
+                const info = deleteMemory.run(memoryId);
+                deleteVec.run(memoryId);
+                return info.changes > 0;
+            })();
+            if (result) {
+                log("deleteMemory: success", { memoryId });
+                return { success: true };
+            }
+            else {
+                log("deleteMemory: not found", { memoryId });
+                return { success: false, error: "Memory not found" };
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log("deleteMemory: error", { memoryId, error: errorMessage });
+            return { success: false, error: errorMessage };
+        }
+    }
+    shutdown() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+        this.isInitialized = false;
+        log("SQLite memory client shutdown");
+    }
+}

package/dist/services/tags.d.ts

@@ -0,0 +1,20 @@
+export interface TagInfo {
+    tag: string;
+    displayName: string;
+    userName?: string;
+    userEmail?: string;
+    projectPath?: string;
+    projectName?: string;
+    gitRepoUrl?: string;
+}
+export declare function getGitEmail(): string | null;
+export declare function getGitName(): string | null;
+export declare function getGitRepoUrl(directory: string): string | null;
+export declare function getProjectName(directory: string): string;
+export declare function getUserTagInfo(): TagInfo;
+export declare function getProjectTagInfo(directory: string): TagInfo;
+export declare function getTags(directory: string): {
+    user: TagInfo;
+    project: TagInfo;
+};
+//# sourceMappingURL=tags.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../../src/services/tags.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,WAAW,IAAI,MAAM,GAAG,IAAI,CAO3C;AAED,wBAAgB,UAAU,IAAI,MAAM,GAAG,IAAI,CAO1C;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAU9D;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED,wBAAgB,cAAc,IAAI,OAAO,CAoBxC;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAW5D;AAED,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG;IAC1C,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;CAClB,CAKA"}

package/dist/services/tags.js

@@ -0,0 +1,76 @@
+import { createHash } from "node:crypto";
+import { execSync } from "node:child_process";
+import { CONFIG } from "../config.js";
+function sha256(input) {
+    return createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+export function getGitEmail() {
+    try {
+        const email = execSync("git config user.email", { encoding: "utf-8" }).trim();
+        return email || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getGitName() {
+    try {
+        const name = execSync("git config user.name", { encoding: "utf-8" }).trim();
+        return name || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getGitRepoUrl(directory) {
+    try {
+        const url = execSync("git config --get remote.origin.url", {
+            encoding: "utf-8",
+            cwd: directory,
+        }).trim();
+        return url || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getProjectName(directory) {
+    const parts = directory.split("/").filter((p) => p);
+    return parts[parts.length - 1] || directory;
+}
+export function getUserTagInfo() {
+    const email = getGitEmail();
+    const name = getGitName();
+    if (email) {
+        return {
+            tag: `${CONFIG.containerTagPrefix}_user_${sha256(email)}`,
+            displayName: name || email,
+            userName: name || undefined,
+            userEmail: email,
+        };
+    }
+    const fallback = process.env.USER || process.env.USERNAME || "anonymous";
+    return {
+        tag: `${CONFIG.containerTagPrefix}_user_${sha256(fallback)}`,
+        displayName: fallback,
+        userName: fallback,
+        userEmail: undefined,
+    };
+}
+export function getProjectTagInfo(directory) {
+    const projectName = getProjectName(directory);
+    const gitRepoUrl = getGitRepoUrl(directory);
+    return {
+        tag: `${CONFIG.containerTagPrefix}_project_${sha256(directory)}`,
+        displayName: directory,
+        projectPath: directory,
+        projectName,
+        gitRepoUrl: gitRepoUrl || undefined,
+    };
+}
+export function getTags(directory) {
+    return {
+        user: getUserTagInfo(),
+        project: getProjectTagInfo(directory),
+    };
+}

package/dist/services/web-server-lock.d.ts

@@ -0,0 +1,12 @@
+export declare class WebServerLock {
+    private pid;
+    private cleanupRegistered;
+    constructor();
+    private registerCleanupHandlers;
+    acquire(port: number, host: string): Promise<boolean>;
+    release(): Promise<boolean>;
+    private isProcessAlive;
+    private writeLock;
+    static cleanup(): void;
+}
+//# sourceMappingURL=web-server-lock.d.ts.map

package/dist/services/web-server-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-server-lock.d.ts","sourceRoot":"","sources":["../../src/services/web-server-lock.ts"],"names":[],"mappings":"AAeA,qBAAa,aAAa;IACxB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,iBAAiB,CAAkB;;IAO3C,OAAO,CAAC,uBAAuB;IAwBzB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAmDrD,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAqCjC,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,SAAS;IAIjB,MAAM,CAAC,OAAO,IAAI,IAAI;CAiCvB"}

package/dist/services/web-server-lock.js

@@ -0,0 +1,157 @@
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { log } from "./logger.js";
+const LOCK_DIR = join(homedir(), ".opencode-mem");
+const LOCK_FILE = join(LOCK_DIR, "webserver.lock");
+export class WebServerLock {
+    pid;
+    cleanupRegistered = false;
+    constructor() {
+        this.pid = process.pid;
+        this.registerCleanupHandlers();
+    }
+    registerCleanupHandlers() {
+        if (this.cleanupRegistered)
+            return;
+        this.cleanupRegistered = true;
+        const cleanup = () => {
+            this.release().catch(() => { });
+        };
+        process.on('exit', cleanup);
+        process.on('SIGTERM', () => {
+            cleanup();
+            process.exit(0);
+        });
+        process.on('SIGINT', () => {
+            cleanup();
+            process.exit(0);
+        });
+        process.on('uncaughtException', (error) => {
+            log("WebServerLock: uncaught exception", { error: String(error) });
+            cleanup();
+            process.exit(1);
+        });
+    }
+    async acquire(port, host) {
+        try {
+            if (existsSync(LOCK_FILE)) {
+                const content = readFileSync(LOCK_FILE, "utf-8");
+                const lockData = JSON.parse(content);
+                const alivePids = lockData.pids.filter(pid => this.isProcessAlive(pid));
+                if (alivePids.length > 0) {
+                    if (lockData.port === port && lockData.host === host) {
+                        alivePids.push(this.pid);
+                        this.writeLock({
+                            pids: alivePids,
+                            port: lockData.port,
+                            host: lockData.host,
+                            startedAt: lockData.startedAt,
+                        });
+                        log("WebServerLock: joined existing server", {
+                            pid: this.pid,
+                            totalInstances: alivePids.length
+                        });
+                        return false;
+                    }
+                    else {
+                        log("WebServerLock: port conflict", {
+                            requestedPort: port,
+                            existingPort: lockData.port
+                        });
+                        throw new Error(`Web server already running on ${lockData.host}:${lockData.port}`);
+                    }
+                }
+            }
+            this.writeLock({
+                pids: [this.pid],
+                port,
+                host,
+                startedAt: Date.now(),
+            });
+            log("WebServerLock: acquired", { pid: this.pid, port, host });
+            return true;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("already running")) {
+                throw error;
+            }
+            log("WebServerLock: acquire error", { error: String(error) });
+            throw error;
+        }
+    }
+    async release() {
+        try {
+            if (!existsSync(LOCK_FILE)) {
+                return true;
+            }
+            const content = readFileSync(LOCK_FILE, "utf-8");
+            const lockData = JSON.parse(content);
+            const remainingPids = lockData.pids.filter(pid => pid !== this.pid && this.isProcessAlive(pid));
+            if (remainingPids.length === 0) {
+                unlinkSync(LOCK_FILE);
+                log("WebServerLock: released (last instance)", { pid: this.pid });
+                return true;
+            }
+            else {
+                this.writeLock({
+                    pids: remainingPids,
+                    port: lockData.port,
+                    host: lockData.host,
+                    startedAt: lockData.startedAt,
+                });
+                log("WebServerLock: released (instances remaining)", {
+                    pid: this.pid,
+                    remaining: remainingPids.length
+                });
+                return false;
+            }
+        }
+        catch (error) {
+            log("WebServerLock: release error", { error: String(error) });
+            return true;
+        }
+    }
+    isProcessAlive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    writeLock(data) {
+        writeFileSync(LOCK_FILE, JSON.stringify(data, null, 2), "utf-8");
+    }
+    static cleanup() {
+        try {
+            if (existsSync(LOCK_FILE)) {
+                const content = readFileSync(LOCK_FILE, "utf-8");
+                const lockData = JSON.parse(content);
+                const alivePids = lockData.pids.filter(pid => {
+                    try {
+                        process.kill(pid, 0);
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                if (alivePids.length === 0) {
+                    unlinkSync(LOCK_FILE);
+                    log("WebServerLock: cleanup completed (no alive processes)");
+                }
+                else {
+                    writeFileSync(LOCK_FILE, JSON.stringify({ ...lockData, pids: alivePids }, null, 2), "utf-8");
+                    log("WebServerLock: cleanup completed (alive processes remain)", {
+                        count: alivePids.length
+                    });
+                }
+            }
+        }
+        catch (error) {
+            log("WebServerLock: cleanup error", { error: String(error) });
+        }
+    }
+}

package/dist/services/web-server-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=web-server-worker.d.ts.map

package/dist/services/web-server-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-server-worker.d.ts","sourceRoot":"","sources":["../../src/services/web-server-worker.ts"],"names":[],"mappings":""}