@haisto/opencode-mem 2.14.3-beta.0

package/dist/services/sqlite/vector-search.js

@@ -0,0 +1,279 @@
+import { getDatabase } from "./sqlite-bootstrap.js";
+import { connectionManager } from "./connection-manager.js";
+import { log } from "../logger.js";
+import { CONFIG } from "../../config.js";
+import { createVectorBackend } from "../vector-backends/backend-factory.js";
+import { ExactScanBackend } from "../vector-backends/exact-scan-backend.js";
+const Database = getDatabase();
+function toBlob(vector) {
+    return vector ? new Uint8Array(vector.buffer) : null;
+}
+export class VectorSearch {
+    backendPromise;
+    fallbackBackend;
+    constructor(backend, fallbackBackend = new ExactScanBackend()) {
+        this.backendPromise = backend
+            ? Promise.resolve(backend)
+            : createVectorBackend({ vectorBackend: CONFIG.vectorBackend });
+        this.fallbackBackend = fallbackBackend;
+    }
+    async getBackend() {
+        return this.backendPromise;
+    }
+    async insertVector(db, record, shard) {
+        const insertMemory = db.prepare(`
+      INSERT INTO memories (
+        id, content, vector, tags_vector, container_tag, tags, type, created_at, updated_at,
+        metadata, display_name, user_name, user_email, project_path, project_name, git_repo_url
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        insertMemory.run(record.id, record.content, toBlob(record.vector), toBlob(record.tagsVector), record.containerTag, record.tags || null, record.type || null, record.createdAt, record.updatedAt, record.metadata || null, record.displayName || null, record.userName || null, record.userEmail || null, record.projectPath || null, record.projectName || null, record.gitRepoUrl || null);
+        try {
+            if (shard) {
+                const backend = await this.getBackend();
+                await backend.insert({ id: record.id, vector: record.vector, shard, kind: "content" });
+                if (record.tagsVector) {
+                    await backend.insert({ id: record.id, vector: record.tagsVector, shard, kind: "tags" });
+                }
+            }
+        }
+        catch (error) {
+            db.prepare(`DELETE FROM memories WHERE id = ?`).run(record.id);
+            throw error;
+        }
+    }
+    async searchInShard(shard, queryVector, containerTag, limit, queryText) {
+        const db = connectionManager.getConnection(shard.dbPath);
+        const backend = await this.getBackend();
+        let contentResults;
+        let tagsResults;
+        try {
+            await backend.rebuildFromShard({ db, shard, kind: "content" });
+            await backend.rebuildFromShard({ db, shard, kind: "tags" });
+            contentResults = await backend.search({
+                db,
+                shard,
+                kind: "content",
+                queryVector,
+                limit: limit * 4,
+            });
+            tagsResults = await backend.search({
+                db,
+                shard,
+                kind: "tags",
+                queryVector,
+                limit: limit * 4,
+            });
+        }
+        catch (error) {
+            log("Vector search degraded to exact scan in shard", {
+                shardId: shard.id,
+                backend: backend.getBackendName(),
+                error: String(error),
+            });
+            await this.fallbackBackend.rebuildFromShard({ db, shard, kind: "content" });
+            await this.fallbackBackend.rebuildFromShard({ db, shard, kind: "tags" });
+            contentResults = await this.fallbackBackend.search({
+                db,
+                shard,
+                kind: "content",
+                queryVector,
+                limit: limit * 4,
+            });
+            tagsResults = await this.fallbackBackend.search({
+                db,
+                shard,
+                kind: "tags",
+                queryVector,
+                limit: limit * 4,
+            });
+        }
+        const scoreMap = new Map();
+        for (const r of contentResults) {
+            scoreMap.set(r.id, { contentSim: 1 - r.distance, tagsSim: 0 });
+        }
+        for (const r of tagsResults) {
+            const entry = scoreMap.get(r.id);
+            if (entry) {
+                entry.tagsSim = 1 - r.distance;
+            }
+            else {
+                scoreMap.set(r.id, { contentSim: 0, tagsSim: 1 - r.distance });
+            }
+        }
+        const ids = Array.from(scoreMap.keys());
+        if (ids.length === 0)
+            return [];
+        const placeholders = ids.map(() => "?").join(",");
+        const rows = db
+            .prepare(containerTag === ""
+            ? `
+      SELECT * FROM memories
+      WHERE id IN (${placeholders})
+    `
+            : `
+      SELECT * FROM memories
+      WHERE id IN (${placeholders}) AND container_tag = ?
+    `)
+            .all(...ids, ...(containerTag === "" ? [] : [containerTag]));
+        const queryWords = queryText
+            ? queryText
+                .toLowerCase()
+                .split(/[\s,]+/)
+                .filter((w) => w.length > 1)
+            : [];
+        const hydratedResults = rows.map((row) => {
+            const scores = scoreMap.get(row.id);
+            const memoryTagsStr = row.tags || "";
+            const memoryTags = memoryTagsStr.split(",").map((t) => t.trim().toLowerCase());
+            let exactMatchBoost = 0;
+            if (queryWords.length > 0 && memoryTags.length > 0) {
+                const matches = queryWords.filter((w) => memoryTags.some((t) => t.includes(w) || w.includes(t))).length;
+                exactMatchBoost = matches / Math.max(queryWords.length, 1);
+            }
+            const finalTagsSim = Math.max(scores.tagsSim, exactMatchBoost);
+            const similarity = scores.contentSim * 0.6 + finalTagsSim * 0.4;
+            return {
+                id: row.id,
+                memory: row.content,
+                similarity,
+                tags: memoryTagsStr ? memoryTagsStr.split(",") : [],
+                metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+                containerTag: row.container_tag,
+                displayName: row.display_name,
+                userName: row.user_name,
+                userEmail: row.user_email,
+                projectPath: row.project_path,
+                projectName: row.project_name,
+                gitRepoUrl: row.git_repo_url,
+                isPinned: row.is_pinned,
+            };
+        });
+        hydratedResults.sort((a, b) => b.similarity - a.similarity);
+        return hydratedResults;
+    }
+    async searchAcrossShards(shards, queryVector, containerTag, limit, similarityThreshold, queryText) {
+        const shardPromises = shards.map(async (shard) => {
+            try {
+                return await this.searchInShard(shard, queryVector, containerTag, limit, queryText);
+            }
+            catch (error) {
+                log("Shard search error", { shardId: shard.id, error: String(error) });
+                return [];
+            }
+        });
+        const resultsArray = await Promise.all(shardPromises);
+        const allResults = resultsArray.flat();
+        allResults.sort((a, b) => b.similarity - a.similarity);
+        return allResults.filter((r) => r.similarity >= similarityThreshold).slice(0, limit);
+    }
+    async deleteVector(db, memoryId, shard) {
+        db.prepare(`DELETE FROM memories WHERE id = ?`).run(memoryId);
+        if (shard) {
+            const backend = await this.getBackend();
+            await backend.delete({ id: memoryId, shard, kind: "content" });
+            await backend.delete({ id: memoryId, shard, kind: "tags" });
+        }
+    }
+    async updateVector(db, memoryId, vector, shard, tagsVector) {
+        db.prepare(`UPDATE memories SET vector = ?, tags_vector = ? WHERE id = ?`).run(toBlob(vector), toBlob(tagsVector), memoryId);
+        if (shard) {
+            const backend = await this.getBackend();
+            await backend.insert({ id: memoryId, vector, shard, kind: "content" });
+            if (tagsVector) {
+                await backend.insert({ id: memoryId, vector: tagsVector, shard, kind: "tags" });
+            }
+            else {
+                await backend.delete({ id: memoryId, shard, kind: "tags" });
+            }
+        }
+    }
+    listMemories(db, containerTag, limit) {
+        const stmt = db.prepare(containerTag === ""
+            ? `
+      SELECT * FROM memories
+      ORDER BY created_at DESC
+      LIMIT ?
+    `
+            : `
+      SELECT * FROM memories
+      WHERE container_tag = ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `);
+        return (containerTag === "" ? stmt.all(limit) : stmt.all(containerTag, limit));
+    }
+    getAllMemories(db) {
+        const stmt = db.prepare(`SELECT * FROM memories ORDER BY created_at DESC`);
+        return stmt.all();
+    }
+    getMemoryById(db, memoryId) {
+        const stmt = db.prepare(`SELECT * FROM memories WHERE id = ?`);
+        return stmt.get(memoryId);
+    }
+    getMemoriesBySessionID(db, sessionID) {
+        const stmt = db.prepare(`
+      SELECT * FROM memories
+      WHERE metadata LIKE ?
+      ORDER BY created_at DESC
+    `);
+        const rows = stmt.all(`%"sessionID":"${sessionID}"%`);
+        return rows.map((row) => ({
+            ...row,
+            tags: row.tags ? row.tags.split(",") : [],
+            metadata: row.metadata ? JSON.parse(row.metadata) : {},
+        }));
+    }
+    countVectors(db, containerTag) {
+        const stmt = db.prepare(`SELECT COUNT(*) as count FROM memories WHERE container_tag = ?`);
+        const result = stmt.get(containerTag);
+        return result.count;
+    }
+    countAllVectors(db) {
+        const stmt = db.prepare(`SELECT COUNT(*) as count FROM memories`);
+        const result = stmt.get();
+        return result.count;
+    }
+    getDistinctTags(db) {
+        const stmt = db.prepare(`
+      SELECT DISTINCT
+        container_tag,
+        display_name,
+        user_name,
+        user_email,
+        project_path,
+        project_name,
+        git_repo_url
+      FROM memories
+    `);
+        return stmt.all();
+    }
+    pinMemory(db, memoryId) {
+        const stmt = db.prepare(`UPDATE memories SET is_pinned = 1 WHERE id = ?`);
+        stmt.run(memoryId);
+    }
+    unpinMemory(db, memoryId) {
+        const stmt = db.prepare(`UPDATE memories SET is_pinned = 0 WHERE id = ?`);
+        stmt.run(memoryId);
+    }
+    async rebuildIndexForShard(db, scope, scopeHash, shardIndex) {
+        const backend = await this.getBackend();
+        const shard = {
+            id: 0,
+            scope: scope,
+            scopeHash,
+            shardIndex,
+            dbPath: "",
+            vectorCount: 0,
+            isActive: true,
+            createdAt: Date.now(),
+        };
+        await backend.rebuildFromShard({ db, shard, kind: "content" });
+        await backend.rebuildFromShard({ db, shard, kind: "tags" });
+    }
+    async deleteShardIndexes(shard) {
+        const backend = await this.getBackend();
+        await backend.deleteShardIndexes({ shard });
+    }
+}
+export const vectorSearch = new VectorSearch();

package/dist/services/tags.d.ts

@@ -0,0 +1,24 @@
+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 getGitCommonDir(directory: string): string | null;
+export declare function getGitTopLevel(directory: string): string | null;
+export declare function getProjectRoot(directory: string): string;
+export declare function getProjectIdentity(directory: string): string;
+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":"AAUA,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,CAU3C;AAED,wBAAgB,UAAU,IAAI,MAAM,GAAG,IAAI,CAU1C;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAW9D;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAwBhE;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAW/D;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAYxD;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAY5D;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAIxD;AAED,wBAAgB,cAAc,IAAI,OAAO,CAoBxC;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAa5D;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,145 @@
+import { createHash } from "node:crypto";
+import { execSync } from "node:child_process";
+import { CONFIG } from "../config.js";
+import { normalize, resolve, isAbsolute, basename, dirname } from "node:path";
+import { realpathSync, existsSync } from "node:fs";
+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",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return email || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getGitName() {
+    try {
+        const name = execSync("git config user.name", {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).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,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return url || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getGitCommonDir(directory) {
+    try {
+        const commonDir = execSync("git rev-parse --git-common-dir", {
+            encoding: "utf-8",
+            cwd: directory,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (!commonDir) {
+            return null;
+        }
+        const resolved = isAbsolute(commonDir)
+            ? normalize(commonDir)
+            : normalize(resolve(directory, commonDir));
+        if (existsSync(resolved)) {
+            return realpathSync(resolved);
+        }
+        return resolved;
+    }
+    catch {
+        return null;
+    }
+}
+export function getGitTopLevel(directory) {
+    try {
+        const topLevel = execSync("git rev-parse --show-toplevel", {
+            encoding: "utf-8",
+            cwd: directory,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return topLevel || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getProjectRoot(directory) {
+    const commonDir = getGitCommonDir(directory);
+    if (commonDir && basename(commonDir) === ".git") {
+        return dirname(commonDir);
+    }
+    const topLevel = getGitTopLevel(directory);
+    if (topLevel) {
+        return topLevel;
+    }
+    return directory;
+}
+export function getProjectIdentity(directory) {
+    const commonDir = getGitCommonDir(directory);
+    if (commonDir) {
+        return `git-common:${commonDir}`;
+    }
+    const gitRepoUrl = getGitRepoUrl(directory);
+    if (gitRepoUrl) {
+        return `remote:${gitRepoUrl}`;
+    }
+    return `path:${normalize(directory)}`;
+}
+export function getProjectName(directory) {
+    const normalized = normalize(directory).replace(/\\/g, "/");
+    const parts = normalized.split("/").filter((p) => p && p !== ".");
+    return parts[parts.length - 1] || directory;
+}
+export function getUserTagInfo() {
+    const email = CONFIG.userEmailOverride || getGitEmail();
+    const name = CONFIG.userNameOverride || getGitName();
+    if (email) {
+        return {
+            tag: `${CONFIG.containerTagPrefix}_user_${sha256(email)}`,
+            displayName: name || email,
+            userName: name || undefined,
+            userEmail: email,
+        };
+    }
+    const fallback = name || 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 projectRoot = getProjectRoot(directory);
+    const projectName = getProjectName(projectRoot);
+    const gitRepoUrl = getGitRepoUrl(directory);
+    const projectIdentity = getProjectIdentity(projectRoot);
+    return {
+        tag: `${CONFIG.containerTagPrefix}_project_${sha256(projectIdentity)}`,
+        displayName: projectRoot,
+        projectPath: projectRoot,
+        projectName,
+        gitRepoUrl: gitRepoUrl || undefined,
+    };
+}
+export function getTags(directory) {
+    return {
+        user: getUserTagInfo(),
+        project: getProjectTagInfo(directory),
+    };
+}

package/dist/services/user-memory-learning.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function performUserProfileLearning(ctx: PluginInput, directory: string): Promise<void>;
+//# sourceMappingURL=user-memory-learning.d.ts.map

package/dist/services/user-memory-learning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-memory-learning.d.ts","sourceRoot":"","sources":["../../src/services/user-memory-learning.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAWvD,wBAAsB,0BAA0B,CAC9C,GAAG,EAAE,WAAW,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAuEf"}