om-memory-system 3.0.0

package/dist/services/runtime-require.js

@@ -0,0 +1,75 @@
+/**
+ * Create a CommonJS require() bound to the current ESM module.
+ *
+ * OpenCode ships as a Bun `--compile` binary. In that host, `import.meta.url`
+ * can be empty for dynamically loaded plugins, so `createRequire(import.meta.url)`
+ * yields `Cannot find module '…' from ''` (#210). Prefer Bun's module-bound
+ * `import.meta.require` when available, then fall back to a valid file/path anchor.
+ */
+import { createRequire } from "node:module";
+import { join } from "node:path";
+function isUsableAnchor(value) {
+    return typeof value === "string" && value.trim().length > 0 && value !== "undefined";
+}
+function collectAnchors(meta) {
+    const anchors = [];
+    if (isUsableAnchor(meta.url))
+        anchors.push(meta.url);
+    if (isUsableAnchor(meta.path))
+        anchors.push(meta.path);
+    const dir = isUsableAnchor(meta.dirname)
+        ? meta.dirname
+        : isUsableAnchor(meta.dir)
+            ? meta.dir
+            : null;
+    if (dir) {
+        // createRequire needs a filename, not a directory.
+        anchors.push(join(dir, "runtime-require.js"));
+    }
+    if (typeof meta.resolve === "function") {
+        try {
+            const resolved = meta.resolve("./package.json");
+            if (isUsableAnchor(resolved))
+                anchors.push(resolved);
+        }
+        catch {
+            // import.meta.resolve may be unavailable or reject relative specifiers.
+        }
+    }
+    return anchors;
+}
+/**
+ * Build a require() for resolving/loading packages next to this plugin module.
+ * Throws a concrete diagnostic when no usable Bun/Node anchor exists.
+ *
+ * Prefer a path/url-anchored createRequire over Bun's import.meta.require when a
+ * concrete file anchor exists. In OpenCode's Bun --compile host, import.meta.url
+ * and import.meta.path are still valid for dynamically imported plugins even when
+ * some require referrers later surface as `from ''` (#210).
+ */
+export function createRuntimeRequire(meta) {
+    const anchors = collectAnchors(meta);
+    const errors = [];
+    for (const anchor of anchors) {
+        try {
+            return createRequire(anchor);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            errors.push(`${anchor}: ${message}`);
+        }
+    }
+    if (typeof meta.require === "function") {
+        return meta.require;
+    }
+    throw new Error([
+        "Unable to create a module require for the OpenCode plugin host.",
+        `import.meta.url=${JSON.stringify(meta.url)}`,
+        `import.meta.path=${JSON.stringify(meta.path)}`,
+        "Bun import.meta.require is unavailable.",
+        errors.length > 0 ? `createRequire attempts: ${errors.join("; ")}` : null,
+        "This usually means the compiled OpenCode/Bun host cleared the plugin module referrer (#210).",
+    ]
+        .filter(Boolean)
+        .join(" "));
+}

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

@@ -0,0 +1 @@
+export declare function resolveSecretValue(value: string | undefined): string | undefined;

package/dist/services/secret-resolver.js

@@ -0,0 +1,65 @@
+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;
+}
+// Any group or other bit set means someone besides the owner can reach the
+// secret. Owner bits are deliberately excluded: 0600 and 0400 are both fine.
+const GROUP_AND_OTHER_BITS = 0o077;
+function checkFilePermissions(filePath) {
+    if (platform() === "win32") {
+        return;
+    }
+    try {
+        const stats = statSync(filePath);
+        const mode = stats.mode & 0o777;
+        // Test the bits, not the numeric value. `mode > 0o600` compared a bitmask as
+        // an integer, so it missed every mode that grants group/other access while
+        // sorting numerically lower -- 0404 (world-readable) and 0006
+        // (world-writable) passed silently, while 0640, strictly less permissive
+        // than 0644, warned. The comparison and the property being checked were
+        // simply unrelated.
+        const exposedBits = mode & GROUP_AND_OTHER_BITS;
+        if (exposedBits !== 0) {
+            console.warn(`Warning: Secret file ${filePath} has permissive permissions (${mode.toString(8).padStart(3, "0")}) granting group/other access. Recommend chmod 600.`);
+        }
+    }
+    catch {
+        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}`, { cause: 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/shard-inventory-service.d.ts

@@ -0,0 +1,69 @@
+export type ShardInventoryStatus = "current" | "linked" | "orphaned" | "missing-file" | "empty" | "ambiguous";
+export interface ProjectShardDescriptor {
+    shardId: number | null;
+    shardIndex: number;
+    dbPath: string;
+    fileName: string;
+    isActive: boolean;
+    vectorCount: number;
+    memoryCount: number;
+    fileExists: boolean;
+}
+export interface ProjectShardGroup {
+    scope: "project";
+    scopeHash: string;
+    shardIndices: number[];
+    shards: ProjectShardDescriptor[];
+    memoryCount: number;
+    containerTag: string | null;
+    projectPath: string | null;
+    projectPathCandidates: Array<{
+        path: string;
+        count: number;
+    }>;
+    projectName: string | null;
+    gitRepoUrl: string | null;
+    pathExists: boolean;
+    status: ShardInventoryStatus;
+    matchesCurrentProject: boolean;
+}
+export interface ListShardsResult {
+    success: true;
+    storagePath: string;
+    currentProject: {
+        tag: string;
+        scopeHash: string;
+        projectPath: string;
+    };
+    shards: ProjectShardGroup[];
+    summary: {
+        total: number;
+        current: number;
+        linked: number;
+        orphaned: number;
+        missingFile: number;
+        empty: number;
+        ambiguous: number;
+    };
+}
+export interface ResolveMigrationSourceOptions {
+    fromPath?: string;
+    fromHash?: string;
+}
+export interface ResolvedMigrationSource {
+    scopeHash: string;
+    matchedBy: "fromHash" | "storedProjectPath" | "liveProjectIdentity";
+    group: ProjectShardGroup;
+}
+export interface ResolveMigrationSourceResult {
+    success: boolean;
+    source?: ResolvedMigrationSource;
+    candidates?: ProjectShardGroup[];
+    error?: string;
+}
+export declare function normalizeProjectPath(path: string): string;
+export declare class ShardInventoryService {
+    listShards(currentDirectory: string): Promise<ListShardsResult>;
+    resolveMigrationSource(currentDirectory: string, options: ResolveMigrationSourceOptions): Promise<ResolveMigrationSourceResult>;
+}
+export declare const shardInventoryService: ShardInventoryService;

package/dist/services/shard-inventory-service.js

@@ -0,0 +1,315 @@
+import { basename, join, normalize, resolve } from "node:path";
+import { existsSync, readdirSync } from "node:fs";
+import { CONFIG } from "../config.js";
+import { assertSafeScopeHash, isValidScopeHash } from "./memory-scope.js";
+import { getProjectTagInfo } from "./tags.js";
+import { ensureTursoReady } from "./turso/ready.js";
+import { tursoShardManager } from "./turso/shard-manager.js";
+import { tursoConnectionManager } from "./turso/connection-manager.js";
+import { tursoVectorSearch } from "./turso/vector-search.js";
+const SHARD_FILENAME_RE = /^(user|project)_([a-f0-9]{16})_shard_(\d+)\.db$/;
+export function normalizeProjectPath(path) {
+    const normalized = normalize(resolve(path)).replace(/\\/g, "/");
+    if (normalized.length > 1 && normalized.endsWith("/")) {
+        return normalized.replace(/\/+$/, "");
+    }
+    return normalized;
+}
+function listProjectShardDbPaths() {
+    const dir = join(CONFIG.storagePath, "projects");
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((file) => file.endsWith(".db") && !file.includes(".bak") && !file.includes(".tmp"))
+        .map((file) => join(dir, file));
+}
+async function inspectShardContent(dbPath) {
+    if (!existsSync(dbPath)) {
+        return {
+            memoryCount: 0,
+            pathCandidates: [],
+            projectName: null,
+            gitRepoUrl: null,
+            containerTag: null,
+        };
+    }
+    const db = await tursoConnectionManager.getConnection(dbPath);
+    const memoryCount = await tursoVectorSearch.countAllVectors(db);
+    const pathCounts = await tursoVectorSearch.getProjectPathCounts(db);
+    const tags = await tursoVectorSearch.getDistinctTags(db);
+    const first = tags[0];
+    // Collapse path+tag rows into path totals while keeping a representative tag.
+    const byPath = new Map();
+    for (const row of pathCounts) {
+        const key = normalizeProjectPath(row.projectPath);
+        const existing = byPath.get(key);
+        if (existing) {
+            existing.count += row.count;
+            if (!existing.containerTag && row.containerTag) {
+                existing.containerTag = row.containerTag;
+            }
+        }
+        else {
+            byPath.set(key, {
+                path: key,
+                count: row.count,
+                containerTag: row.containerTag,
+            });
+        }
+    }
+    const pathCandidates = [...byPath.values()].sort((a, b) => b.count - a.count || a.path.localeCompare(b.path));
+    return {
+        memoryCount,
+        pathCandidates,
+        projectName: first?.project_name ? String(first.project_name) : null,
+        gitRepoUrl: first?.git_repo_url ? String(first.git_repo_url) : null,
+        containerTag: pathCandidates[0]?.containerTag ??
+            (first?.container_tag ? String(first.container_tag) : null),
+    };
+}
+function deriveStatus(input) {
+    if (input.pathCandidates.length > 1) {
+        return "ambiguous";
+    }
+    if (input.allFilesMissing) {
+        return "missing-file";
+    }
+    if (input.memoryCount === 0) {
+        return "empty";
+    }
+    if (input.matchesCurrentProject) {
+        return "current";
+    }
+    if (input.projectPath && !input.pathExists) {
+        return "orphaned";
+    }
+    if (input.projectPath && input.pathExists) {
+        return "linked";
+    }
+    if (input.anyFileMissing) {
+        return "missing-file";
+    }
+    return "orphaned";
+}
+export class ShardInventoryService {
+    async listShards(currentDirectory) {
+        await ensureTursoReady();
+        const current = getProjectTagInfo(currentDirectory);
+        const currentHash = current.tag.split("_").pop();
+        assertSafeScopeHash(currentHash);
+        const registered = await tursoShardManager.getAllShards("project", "");
+        const byHash = new Map();
+        for (const shard of registered) {
+            const entry = byHash.get(shard.scopeHash) ?? { registered: [], filePaths: new Set() };
+            entry.registered.push(shard);
+            entry.filePaths.add(shard.dbPath);
+            byHash.set(shard.scopeHash, entry);
+        }
+        for (const path of listProjectShardDbPaths()) {
+            const match = SHARD_FILENAME_RE.exec(basename(path));
+            if (!match || match[1] !== "project")
+                continue;
+            const scopeHash = match[2];
+            const entry = byHash.get(scopeHash) ?? { registered: [], filePaths: new Set() };
+            entry.filePaths.add(path);
+            byHash.set(scopeHash, entry);
+        }
+        const groups = [];
+        for (const [scopeHash, entry] of byHash) {
+            const shardIndexes = new Set();
+            for (const shard of entry.registered) {
+                shardIndexes.add(shard.shardIndex);
+            }
+            for (const path of entry.filePaths) {
+                const match = SHARD_FILENAME_RE.exec(basename(path));
+                if (match)
+                    shardIndexes.add(Number(match[3]));
+            }
+            const descriptors = [];
+            let memoryCount = 0;
+            const pathCountMap = new Map();
+            let projectName = null;
+            let gitRepoUrl = null;
+            let containerTag = null;
+            for (const shardIndex of [...shardIndexes].sort((a, b) => a - b)) {
+                const registeredShard = entry.registered.find((shard) => shard.shardIndex === shardIndex) ?? null;
+                const dbPath = registeredShard?.dbPath ??
+                    tursoShardManager.getShardPath("project", scopeHash, shardIndex);
+                const fileExists = existsSync(dbPath);
+                const content = await inspectShardContent(dbPath);
+                memoryCount += content.memoryCount;
+                for (const candidate of content.pathCandidates) {
+                    pathCountMap.set(candidate.path, (pathCountMap.get(candidate.path) ?? 0) + candidate.count);
+                    if (!containerTag && candidate.containerTag) {
+                        containerTag = candidate.containerTag;
+                    }
+                }
+                if (!projectName && content.projectName)
+                    projectName = content.projectName;
+                if (!gitRepoUrl && content.gitRepoUrl)
+                    gitRepoUrl = content.gitRepoUrl;
+                if (!containerTag && content.containerTag)
+                    containerTag = content.containerTag;
+                descriptors.push({
+                    shardId: registeredShard?.id ?? null,
+                    shardIndex,
+                    dbPath,
+                    fileName: basename(dbPath),
+                    isActive: registeredShard?.isActive ?? shardIndex === Math.max(...shardIndexes),
+                    vectorCount: registeredShard?.vectorCount ?? content.memoryCount,
+                    memoryCount: content.memoryCount,
+                    fileExists,
+                });
+            }
+            const projectPathCandidates = [...pathCountMap.entries()]
+                .map(([path, count]) => ({ path, count }))
+                .sort((a, b) => b.count - a.count || a.path.localeCompare(b.path));
+            const projectPath = projectPathCandidates[0]?.path ?? null;
+            const pathExists = projectPath ? existsSync(projectPath) : false;
+            const matchesCurrentProject = scopeHash === currentHash;
+            const anyFileMissing = descriptors.some((shard) => !shard.fileExists);
+            const allFilesMissing = descriptors.length > 0 && descriptors.every((shard) => !shard.fileExists);
+            groups.push({
+                scope: "project",
+                scopeHash,
+                shardIndices: descriptors.map((shard) => shard.shardIndex),
+                shards: descriptors,
+                memoryCount,
+                containerTag: containerTag ?? `${CONFIG.containerTagPrefix}_project_${scopeHash}`,
+                projectPath,
+                projectPathCandidates,
+                projectName,
+                gitRepoUrl,
+                pathExists,
+                status: deriveStatus({
+                    matchesCurrentProject,
+                    memoryCount,
+                    pathExists,
+                    projectPath,
+                    pathCandidates: projectPathCandidates,
+                    anyFileMissing,
+                    allFilesMissing,
+                }),
+                matchesCurrentProject,
+            });
+        }
+        groups.sort((a, b) => {
+            if (a.matchesCurrentProject !== b.matchesCurrentProject) {
+                return a.matchesCurrentProject ? -1 : 1;
+            }
+            return b.memoryCount - a.memoryCount || a.scopeHash.localeCompare(b.scopeHash);
+        });
+        const summary = {
+            total: groups.length,
+            current: groups.filter((g) => g.status === "current").length,
+            linked: groups.filter((g) => g.status === "linked").length,
+            orphaned: groups.filter((g) => g.status === "orphaned").length,
+            missingFile: groups.filter((g) => g.status === "missing-file").length,
+            empty: groups.filter((g) => g.status === "empty").length,
+            ambiguous: groups.filter((g) => g.status === "ambiguous").length,
+        };
+        return {
+            success: true,
+            storagePath: CONFIG.storagePath,
+            currentProject: {
+                tag: current.tag,
+                scopeHash: currentHash,
+                projectPath: current.projectPath || getProjectTagInfo(currentDirectory).displayName,
+            },
+            shards: groups,
+            summary,
+        };
+    }
+    async resolveMigrationSource(currentDirectory, options) {
+        const inventory = await this.listShards(currentDirectory);
+        const { fromHash, fromPath } = options;
+        if (fromHash) {
+            if (!isValidScopeHash(fromHash)) {
+                return {
+                    success: false,
+                    error: `Invalid fromHash: expected 16 lowercase hex characters, got "${fromHash}"`,
+                };
+            }
+            const group = inventory.shards.find((shard) => shard.scopeHash === fromHash);
+            if (!group) {
+                return {
+                    success: false,
+                    error: `No project shards found for hash ${fromHash}. Run memory list-shards to inspect available shards.`,
+                };
+            }
+            if (group.memoryCount === 0) {
+                return {
+                    success: false,
+                    error: `Shard hash ${fromHash} exists but contains no memories.`,
+                };
+            }
+            return {
+                success: true,
+                source: {
+                    scopeHash: fromHash,
+                    matchedBy: "fromHash",
+                    group,
+                },
+            };
+        }
+        if (!fromPath || !fromPath.trim()) {
+            return {
+                success: false,
+                error: "fromPath or fromHash is required for migrate",
+            };
+        }
+        const normalizedFrom = normalizeProjectPath(fromPath);
+        const pathMatches = inventory.shards.filter((group) => group.projectPathCandidates.some((candidate) => candidate.path === normalizedFrom));
+        if (pathMatches.length === 1) {
+            const group = pathMatches[0];
+            if (group.memoryCount === 0) {
+                return {
+                    success: false,
+                    error: `Matched project path ${normalizedFrom} but the shard contains no memories.`,
+                };
+            }
+            return {
+                success: true,
+                source: {
+                    scopeHash: group.scopeHash,
+                    matchedBy: "storedProjectPath",
+                    group,
+                },
+            };
+        }
+        if (pathMatches.length > 1) {
+            return {
+                success: false,
+                error: `Ambiguous fromPath match for ${normalizedFrom}. Use fromHash with memory list-shards to select one shard.`,
+                candidates: pathMatches,
+            };
+        }
+        // If the old directory still exists, resolve its live project identity.
+        if (existsSync(normalizedFrom)) {
+            try {
+                const live = getProjectTagInfo(normalizedFrom);
+                const liveHash = live.tag.split("_").pop();
+                const group = inventory.shards.find((shard) => shard.scopeHash === liveHash);
+                if (group && group.memoryCount > 0) {
+                    return {
+                        success: true,
+                        source: {
+                            scopeHash: liveHash,
+                            matchedBy: "liveProjectIdentity",
+                            group,
+                        },
+                    };
+                }
+            }
+            catch {
+                // Fall through to the generic missing-source error.
+            }
+        }
+        return {
+            success: false,
+            error: `No shard found for fromPath ${normalizedFrom}. ` +
+                `If the old directory no longer exists, run memory list-shards and migrate with fromHash.`,
+        };
+    }
+}
+export const shardInventoryService = new ShardInventoryService();

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

@@ -0,0 +1,31 @@
+import { type ResolveMigrationSourceOptions, type ResolvedMigrationSource } from "./shard-inventory-service.js";
+export interface PathMigrationOptions extends ResolveMigrationSourceOptions {
+    currentDirectory: string;
+    dryRun?: boolean;
+    allowLinkedSource?: boolean;
+}
+export interface PathMigrationAction {
+    type: "rename" | "archive-empty-target" | "update-memories" | "update-prompts" | "reassign-metadata";
+    detail: string;
+}
+export interface PathMigrationResult {
+    success: boolean;
+    dryRun: boolean;
+    migratedShards?: number;
+    migratedMemories?: number;
+    oldPath?: string | null;
+    newPath?: string;
+    oldHash?: string;
+    newHash?: string;
+    matchedBy?: ResolvedMigrationSource["matchedBy"];
+    actions?: PathMigrationAction[];
+    error?: string;
+    candidates?: unknown[];
+}
+export declare class ShardPathMigrationService {
+    migrate(options: PathMigrationOptions): Promise<PathMigrationResult>;
+    private rollbackSwap;
+    /** Roll back an interrupted staged swap before normal storage access resumes. */
+    recoverInterruptedSwap(): Promise<void>;
+}
+export declare const shardPathMigrationService: ShardPathMigrationService;