om-memory-system 4.8.0 → 4.10.0

package/dist/importer/map-suggestions.js

@@ -1,6 +1,6 @@
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { basename, dirname, join, parse } from "node:path";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, join, parse, resolve, sep } from "node:path";
 const PROJECT_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod"];
 function isDirectory(path) {
     try {
@@ -10,8 +10,45 @@ function isDirectory(path) {
         return false;
     }
 }
-function isProject(path) {
-    return PROJECT_MARKERS.some((marker) => existsSync(join(path, marker)));
+function isProject(path, projects) {
+    const cached = projects?.get(path);
+    if (cached !== undefined)
+        return cached;
+    const found = PROJECT_MARKERS.some((marker) => existsSync(join(path, marker)));
+    projects?.set(path, found);
+    return found;
+}
+/** Windows paths can mix `\` and `/`, so both count as a separator here. */
+function isInside(path, folder) {
+    const slashes = (value) => value.replace(/\\/g, "/").replace(/\/+$/, "");
+    const inner = slashes(path);
+    const outer = slashes(folder);
+    return inner === outer || inner.startsWith(`${outer}/`);
+}
+/**
+ * The main working tree of a linked Git worktree, from the `gitdir:` line of
+ * its `.git` file; the folder itself otherwise. Null when a linked worktree's
+ * main tree is gone. Reads one file and starts no `git` process.
+ */
+function projectRoot(path) {
+    let gitFile;
+    try {
+        if (!statSync(join(path, ".git")).isFile())
+            return path;
+        gitFile = readFileSync(join(path, ".git"), "utf8");
+    }
+    catch {
+        return path;
+    }
+    const gitdir = /^gitdir:\s*(.+)$/m.exec(gitFile)?.[1]?.trim();
+    if (!gitdir)
+        return path;
+    const marker = `${sep}.git${sep}worktrees${sep}`;
+    const at = resolve(path, gitdir).indexOf(marker);
+    if (at < 0)
+        return path;
+    const main = resolve(path, gitdir).slice(0, at);
+    return isDirectory(main) && isProject(main) ? main : null;
 }
 function childDirectories(parent, cache) {
     const cached = cache?.get(parent);
@@ -33,23 +70,112 @@ function childDirectories(parent, cache) {
 function isLeadingPart(candidate, name) {
     return name === candidate || name.startsWith(`${candidate}-`);
 }
+function nameParts(name) {
+    return name
+        .toLowerCase()
+        .split(/[-_.]+/)
+        .filter(Boolean);
+}
 /**
- * Suggest an existing target for a directory that no longer exists: first the
- * main repository of a deleted worktree, by the longest leading part of the
- * directory's name or one of its parents' names, then OpenCode's recorded
- * project worktree. Returns null when there is no candidate.
+ * True when every part of `candidate` matches, in order, one part of
+ * `missing` or the initials of two or more consecutive parts, and at least two
+ * parts match exactly: `om-pi-subagents` for `opinionated-modular-pi-subagents-system`.
  */
-export function suggestMapTarget(missing, context = {}) {
-    const searchRoots = new Set();
-    for (const project of context.knownProjects ?? []) {
-        if (!isDirectory(project))
+function isRenameOf(candidate, missing) {
+    const want = nameParts(missing);
+    let next = 0;
+    let exact = 0;
+    for (const part of nameParts(candidate)) {
+        let matched = false;
+        for (let at = next; at < want.length && !matched; at++) {
+            if (want[at] === part) {
+                exact++;
+                next = at + 1;
+                matched = true;
+                continue;
+            }
+            for (let end = at + 2; end <= want.length; end++) {
+                const initials = want
+                    .slice(at, end)
+                    .map((word) => word[0])
+                    .join("");
+                if (initials !== part)
+                    continue;
+                next = end;
+                matched = true;
+                break;
+            }
+        }
+        if (!matched)
+            return false;
+    }
+    return exact >= 2;
+}
+/** Folders that never hold a project worth mapping. Pure path checks. */
+function notProjectReason(missing, home, claudeFolder = join(home, ".claude")) {
+    if (missing.split(/[\\/]/).includes("node_modules"))
+        return "node_modules";
+    if (isInside(missing, join(home, "Library", "Application Support")))
+        return "app-data";
+    const skills = [join(home, ".agents", "skills"), join(claudeFolder, "skills")];
+    if (skills.some((folder) => isInside(missing, folder)))
+        return "skills";
+    const temporary = ["/tmp", "/private/tmp", "/private/var/folders", tmpdir()];
+    if (!temporary.some((folder) => isInside(missing, folder)))
+        return null;
+    // A test home sits in a temporary folder; its projects are not temporary.
+    // Windows is the other way round: its temporary folder sits in the home folder.
+    const homeIsTemporary = temporary.some((folder) => isInside(home, folder));
+    return homeIsTemporary && isInside(missing, home) ? null : "temporary";
+}
+/** The one distinct target in `targets`, after resolving linked worktrees; null otherwise. */
+function onlyTarget(targets, missing) {
+    const found = new Set();
+    for (const target of targets) {
+        if (target === missing || !isDirectory(target))
             continue;
-        searchRoots.add(dirname(project));
+        const root = projectRoot(target);
+        if (root)
+            found.add(root);
     }
-    // Never list the filesystem root or the folder that holds every home folder,
-    // and stop at the home folder itself: broad scans suggest unrelated folders.
-    const home = context.home ?? homedir();
-    const blocked = new Set([parse(missing).root, dirname(home)]);
+    return found.size === 1 ? [...found][0] : null;
+}
+/** Rule 2: the one existing project with the git remote the store recorded for `missing`. */
+function sameRemote(recorded, known) {
+    // Store paths are resolved; a recorded path may carry a trailing separator.
+    const missing = resolve(recorded);
+    const remotes = new Set(known
+        .filter((project) => project.path === missing || project.candidates?.includes(missing))
+        .map((project) => project.remote)
+        .filter((remote) => Boolean(remote)));
+    if (!remotes.size)
+        return null;
+    const matches = known.filter((project) => project.remote && remotes.has(project.remote));
+    return onlyTarget(matches.flatMap((project) => [
+        project.path,
+        // An older recorded folder may now hold another project, so it must still have the remote.
+        ...(project.candidates ?? []).filter((path) => {
+            const root = isDirectory(path) ? projectRoot(path) : null;
+            return root !== null && originUrl(root) === project.remote;
+        }),
+    ]), missing);
+}
+/** `remote.origin.url` from a repository's `.git/config`, read without starting `git`. */
+function originUrl(root) {
+    try {
+        const config = readFileSync(join(root, ".git", "config"), "utf8");
+        const origin = /\[remote "origin"\]([^[]*)/.exec(config)?.[1] ?? "";
+        return /^\s*url\s*=\s*(.+?)\s*$/m.exec(origin)?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Rule 4: the main repository of a deleted worktree, by the longest leading
+ * part of the directory's name or one of its parents' names.
+ */
+function deletedWorktree(missing, searchRoots, blocked, home, cache, projects) {
     let ancestor = missing;
     while (dirname(ancestor) !== ancestor && ancestor !== home) {
         const name = basename(ancestor);
@@ -58,26 +184,118 @@ export function suggestMapTarget(missing, context = {}) {
         for (const parent of parents) {
             if (blocked.has(parent))
                 continue;
-            for (const candidate of childDirectories(parent, context.cache)) {
+            for (const candidate of childDirectories(parent, cache)) {
                 if (candidate === ancestor || !isLeadingPart(basename(candidate), name))
                     continue;
-                if (!isProject(candidate))
+                if (!isProject(candidate, projects))
+                    continue;
+                const root = projectRoot(candidate);
+                if (!root)
                     continue;
-                if (!best || basename(candidate).length > basename(best).length)
-                    best = candidate;
+                if (!best || basename(candidate).length > best.name.length) {
+                    best = { name: basename(candidate), root };
+                }
             }
         }
         if (best)
-            return best;
+            return best.root;
         ancestor = dirname(ancestor);
     }
-    const worktree = context.opencodeWorktree?.(missing);
-    if (worktree && worktree !== "/" && isDirectory(worktree))
-        return worktree;
     return null;
 }
+/** Rule 6: the one project beside `missing` or beside a known project whose name is a rename of it. */
+function renameGuess(missing, searchRoots, blocked, cache, projects) {
+    const name = basename(missing);
+    const candidates = [];
+    for (const parent of new Set([dirname(missing), ...searchRoots])) {
+        if (blocked.has(parent))
+            continue;
+        for (const candidate of childDirectories(parent, cache)) {
+            if (isRenameOf(basename(candidate), name) && isProject(candidate, projects)) {
+                candidates.push(candidate);
+            }
+        }
+    }
+    return onlyTarget(candidates, missing);
+}
+/**
+ * The parent folders of existing known projects, searched for siblings. The
+ * home folder and folders that are not projects (temporary, `node_modules`,
+ * app data, skills) are left out: their other children are rarely related.
+ */
+function searchRootsOf(known, home, claudeFolder) {
+    const roots = new Set();
+    for (const project of known) {
+        if (!isDirectory(project.path))
+            continue;
+        const parent = dirname(project.path);
+        if (parent === home || notProjectReason(parent, home, claudeFolder))
+            continue;
+        roots.add(parent);
+    }
+    return roots;
+}
+/** Rules 4 to 6 for one missing directory, first result wins. */
+function suggestByName(missing, context, home) {
+    const known = context.knownProjects ?? [];
+    const searchRoots = context.searchRoots ?? searchRootsOf(known, home, context.claudeFolder);
+    // Never list the filesystem root or the folder that holds every home folder,
+    // and stop at the home folder itself: broad scans suggest unrelated folders.
+    const blocked = new Set([parse(missing).root, dirname(home)]);
+    const worktree = deletedWorktree(missing, searchRoots, blocked, home, context.cache, context.projects);
+    if (worktree)
+        return { kind: "map", target: worktree, confidence: "name" };
+    const moved = onlyTarget(known
+        .flatMap((project) => [project.path, ...(project.candidates ?? [])])
+        .filter((path) => basename(path) === basename(missing)), missing);
+    if (moved)
+        return { kind: "map", target: moved, confidence: "name" };
+    const renamed = renameGuess(missing, searchRoots, blocked, context.cache, context.projects);
+    if (renamed)
+        return { kind: "map", target: renamed, confidence: "guess" };
+    return null;
+}
+/**
+ * Suggest what to do with a directory that no longer exists. Rules run in
+ * order and the first result wins: (1) ignore a folder that is not a project,
+ * (2) the project with the same stored git remote, (3) OpenCode's recorded
+ * project folder, or rules 2 and 4 to 6 on it when it is gone too, (4) the
+ * main repository of a deleted worktree, (5) the one known project with the
+ * same folder name, (6) a rename guess by name parts and initials. Returns
+ * null when no rule gives a result. Reads folders and `.git` files only.
+ */
+export function suggestMapTarget(missing, context = {}) {
+    const home = context.home ?? homedir();
+    const reason = notProjectReason(missing, home, context.claudeFolder);
+    if (reason)
+        return { kind: "ignore", reason };
+    const known = context.knownProjects ?? [];
+    const byRemote = (path) => {
+        const target = sameRemote(path, known);
+        return target ? { kind: "map", target, confidence: "exact" } : null;
+    };
+    const remote = byRemote(missing);
+    if (remote)
+        return remote;
+    const recorded = context.opencodeWorktree?.(missing);
+    if (recorded && recorded !== "/" && recorded !== missing) {
+        if (isDirectory(recorded))
+            return { kind: "map", target: recorded, confidence: "exact" };
+        // One level deep: the recorded folder is gone too.
+        const followed = byRemote(recorded) ?? suggestByName(recorded, context, home);
+        if (followed)
+            return followed;
+    }
+    return suggestByName(missing, context, home);
+}
 export function suggestMapTargets(directories, context = {}) {
-    const withCache = { ...context, cache: context.cache ?? new Map() };
+    const withCache = {
+        ...context,
+        cache: context.cache ?? new Map(),
+        projects: context.projects ?? new Map(),
+        searchRoots: context.searchRoots ??
+            searchRootsOf(context.knownProjects ?? [], context.home ?? homedir(), context.claudeFolder),
+    };
     return directories.map((item) => ({
         ...item,
         // Sessions with no recorded directory have nothing to map.
@@ -105,14 +323,42 @@ export async function readOpencodeWorktrees(dbPath) {
     }
 }
 /**
- * The Directory maps list: saved maps and each host's unresolved directories
- * from its latest run, with suggestions. Paths and counts only.
+ * The memory store's projects with their recorded paths and git remote, read
+ * once through the shard inventory. Empty when there is no store or the read
+ * fails, so the other sources still give suggestions. Never creates a store.
+ */
+export async function readStoreProjects(currentDirectory) {
+    try {
+        const { CONFIG } = await import("../config.js");
+        if (!existsSync(join(CONFIG.storagePath, "metadata.db")))
+            return [];
+        const { shardInventoryService } = await import("../services/shard-inventory-service.js");
+        const inventory = await shardInventoryService.listShards(currentDirectory);
+        return inventory.shards.flatMap((group) => {
+            const candidates = group.projectPathCandidates.map((candidate) => resolve(candidate.path));
+            const path = group.projectPath ? resolve(group.projectPath) : candidates[0];
+            return path ? [{ path, candidates, remote: group.gitRepoUrl }] : [];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * The Directory maps list: saved maps, ignored directories, and each host's
+ * unresolved directories from its latest run, with suggestions. Paths and
+ * counts only.
  */
 export async function directoryMapsView(options = {}) {
     const { CONFIG } = await import("../config.js");
     const { readUnresolvedDirectories } = await import("../services/backfill-state.js");
     const { DEFAULT_OPENCODE_DB } = await import("./opencode-reader.js");
+    const { resolveClaudeFolder } = await import("../services/claude-folder.js");
+    const claudeFolder = resolveClaudeFolder(CONFIG.claudeConfigDir).folder;
     const saved = new Set(CONFIG.importPathMaps.map((map) => map.from));
+    // Older config stubs in tests have no list.
+    const ignored = CONFIG.importIgnoredDirectories ?? [];
+    const hidden = new Set([...saved, ...ignored].map((path) => resolve(path)));
     let worktrees = new Map();
     const dbPath = options.opencodeDbPath ?? DEFAULT_OPENCODE_DB;
     if (existsSync(dbPath)) {
@@ -120,18 +366,22 @@ export async function directoryMapsView(options = {}) {
     }
     const knownProjects = [
         ...(options.knownProjects ?? []),
-        ...CONFIG.importPathMaps.map((map) => map.to),
-        ...worktrees.values(),
+        ...CONFIG.importPathMaps.map((map) => ({ path: map.to })),
+        ...[...worktrees.values()].map((path) => ({ path })),
     ];
     const host = async (name) => {
-        const pending = (await readUnresolvedDirectories(name)).filter((item) => !saved.has(item.directory));
+        const pending = (await readUnresolvedDirectories(name)).filter(
+        // Config paths are resolved; a recorded path may carry a trailing separator.
+        (item) => !item.directory || !hidden.has(resolve(item.directory)));
         return suggestMapTargets(pending, {
             knownProjects,
+            claudeFolder,
             ...(name === "opencode" ? { opencodeWorktree: (dir) => worktrees.get(dir) } : {}),
         });
     };
     return {
         saved: CONFIG.importPathMaps,
+        ignored,
         pi: await host("pi"),
         opencode: await host("opencode"),
         "claude-code": await host("claude-code"),

package/dist/importer/web-import-api.d.ts

@@ -8,6 +8,6 @@ export { listImportSessions, validateSessionListRequest } from "./import-session
 export { opencodeSnapshots, sweepOrphanSnapshots } from "./opencode-snapshot.js";
 export { stopStandaloneOpencodeReads } from "./opencode-standalone-models.js";
 export { BackfillControls } from "./backfill-controls.js";
-export { directoryMapsView } from "./map-suggestions.js";
+export { directoryMapsView, readStoreProjects, type KnownProject } from "./map-suggestions.js";
 export { testExternalApi } from "./external-api-test.js";
 export { catchUpState, pauseCatchUp, previewCatchUp, startCatchUp } from "./profile-catch-up.js";

package/dist/importer/web-import-api.js

@@ -8,6 +8,6 @@ export { listImportSessions, validateSessionListRequest } from "./import-session
 export { opencodeSnapshots, sweepOrphanSnapshots } from "./opencode-snapshot.js";
 export { stopStandaloneOpencodeReads } from "./opencode-standalone-models.js";
 export { BackfillControls } from "./backfill-controls.js";
-export { directoryMapsView } from "./map-suggestions.js";
+export { directoryMapsView, readStoreProjects } from "./map-suggestions.js";
 export { testExternalApi } from "./external-api-test.js";
 export { catchUpState, pauseCatchUp, previewCatchUp, startCatchUp } from "./profile-catch-up.js";

package/dist/services/backfill-state.d.ts

@@ -51,6 +51,16 @@ export declare function unresolvedSessionCount(report: {
     }>;
     unresolvableSessions: ReadonlyArray<unknown>;
 }): number;
+/**
+ * A host's unresolved session count without the sessions in ignored
+ * directories. It comes from the saved directory list, the same list the
+ * Directory maps page shows, because a later listing or CLI run can replace
+ * that list after the run that set `count`. With no list, or a list cut at
+ * {@link MAX_UNRESOLVED_DIRECTORIES}, it subtracts from `count` instead and
+ * stops at 0. Sessions with no recorded directory always count. Paths are
+ * compared in resolved form.
+ */
+export declare function visibleUnresolvedCount(count: number, directories: readonly UnresolvedDirectory[], ignored: readonly string[]): number;
 /**
  * Save the unresolved directories of a host's latest full run or listing. They
  * live in their own table, so recording them never sets a backfill cutoff.

package/dist/services/backfill-state.js

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { CONFIG } from "../config.js";
 import { tursoConnectionManager } from "./turso/connection-manager.js";
 import { safeHealthError } from "./safe-health-error.js";
@@ -79,6 +79,24 @@ export function unresolvedSessionCount(report) {
     const mapped = (report.unresolvedProjects ?? []).reduce((sum, item) => sum + item.sessions, 0);
     return mapped + report.unresolvableSessions.length;
 }
+/**
+ * A host's unresolved session count without the sessions in ignored
+ * directories. It comes from the saved directory list, the same list the
+ * Directory maps page shows, because a later listing or CLI run can replace
+ * that list after the run that set `count`. With no list, or a list cut at
+ * {@link MAX_UNRESOLVED_DIRECTORIES}, it subtracts from `count` instead and
+ * stops at 0. Sessions with no recorded directory always count. Paths are
+ * compared in resolved form.
+ */
+export function visibleUnresolvedCount(count, directories, ignored) {
+    const skip = new Set(ignored.map((path) => resolve(path)));
+    const isIgnored = (item) => item.directory !== NO_DIRECTORY && skip.has(resolve(item.directory));
+    const sum = (items) => items.reduce((total, item) => total + item.sessions, 0);
+    if (directories.length > 0 && directories.length < MAX_UNRESOLVED_DIRECTORIES) {
+        return sum(directories.filter((item) => !isIgnored(item)));
+    }
+    return Math.max(0, count - sum(directories.filter(isIgnored)));
+}
 /**
  * Save the unresolved directories of a host's latest full run or listing. They
  * live in their own table, so recording them never sets a backfill cutoff.

package/dist/services/global-config-writer.js

@@ -23,6 +23,7 @@ const keys = new Set([
     "memoryModel",
     "memoryApiKey",
     "importPathMaps",
+    "importIgnoredDirectories",
     "claudeConfigDir",
     "maxMemories",
     "chatMessage.maxMemories",
@@ -81,7 +82,7 @@ function isValidEdit(key, value) {
     if (key === "memoryProvider")
         return MEMORY_PROVIDERS.includes(value);
     // Entries are checked by the startup validation below.
-    if (key === "importPathMaps")
+    if (key === "importPathMaps" || key === "importIgnoredDirectories")
         return Array.isArray(value);
     // The five memory limits share one validation rule set.
     const memoryLimit = getMemoryLimitRule(key);

package/dist/services/settings-snapshot.js

@@ -24,6 +24,7 @@ const editable = [
     "memoryApiUrl",
     "memoryModel",
     "importPathMaps",
+    "importIgnoredDirectories",
     "claudeConfigDir",
     ...MEMORY_LIMIT_SETTINGS,
 ];
@@ -37,6 +38,7 @@ const globalOnly = [
     "memoryProvider",
     "memoryApiUrl",
     "importPathMaps",
+    "importIgnoredDirectories",
     "claudeConfigDir",
 ];
 function readSettingsFile(path) {

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

@@ -1,3 +1,4 @@
+import type { WebUpdate } from "./web-update.js";
 import { WebAuth } from "./web-auth.js";
 type NodeEventSource = {
     on(event: string, listener: (...args: any[]) => void): unknown;
@@ -37,6 +38,7 @@ export declare class WebServer {
     private onPortsExhaustedCallback;
     private onStepAsideCallback;
     private onPowerActionCallback;
+    private webUpdate;
     private powerActionRunning;
     private stepAsideTimer;
     private holdOffTimer;
@@ -45,6 +47,8 @@ export declare class WebServer {
     private readonly maxFallbackPort;
     private settingsImportJobs?;
     private backfillControlsInstance?;
+    /** The memory store's projects for Directory maps suggestions, read at most once a minute. */
+    private storeProjects?;
     /** Run an import-page action; errors carry their own status and never file contents. */
     private importResponse;
     /** Claude Code hook requests; they reach this point only with a valid API token. */
@@ -57,9 +61,13 @@ export declare class WebServer {
     /** Standalone web apps register this to exit when a newer OMMS asks them to step aside. */
     setOnStepAside(callback: () => void | Promise<void>): void;
     /** Standalone web apps register this to stop or restart from the page. */
-    setOnPowerAction(callback: (action: PowerAction) => void | Promise<void>): void;
+    setOnPowerAction(callback: (action: PowerAction) => unknown): void;
+    /** Standalone web apps register this to report and install npm releases. */
+    setWebUpdate(update: Pick<WebUpdate, "status" | "requestInstall">): void;
     /** Only a local caller may stop the web app; the token alone is not enough. */
     private handlePowerAction;
+    /** Install the npm release and restart onto it. Same guards as Restart. */
+    private handleUpdate;
     /** API token routes. Only a caller on this machine with the local token manages tokens. */
     private handleTokenRoute;
     /** Profile catch-up: a preview for anyone with API access; runs only from this machine. */
@@ -75,6 +83,7 @@ export declare class WebServer {
     start(): Promise<void>;
     private _start;
     private startHealthCheckLoop;
+    private ownerIsNewer;
     private stopHealthCheckLoop;
     private attemptTakeover;
     private notifyPortsExhausted;