Class LocalMemoryStore

src/node/services/memoryService.ts:296–418

}

class LocalMemoryStore implements MemoryStore {
  constructor(readonly physicalRoot: string) {}

  private abs(relPath: string): string {
    return relPath === "" ? this.physicalRoot : path.join(this.physicalRoot, ...relPath.split("/"));
  }

  assertRootSafe(): Promise<void> {
    // Host-local roots are trusted; per-target symlink escape checks happen in assertContained().
    return Promise.resolve();
  }

  async ensureRoot(): Promise<void> {
    await this.assertRootSafe();
    await fsPromises.mkdir(this.physicalRoot, { recursive: true });
  }

  async listFiles(): Promise<string[]> {
    const results: string[] = [];
    const walk = async (dirRel: string): Promise<void> => {
      // Bounded walk: files may have been edited outside MemoryService. +1 lets
      // callers detect overflow (e.g. the index logs its truncation).
      if (results.length > MEMORY_MAX_FILES_PER_SCOPE) return;
      let entries;
      try {
        entries = await fsPromises.readdir(this.abs(dirRel), { withFileTypes: true });
      } catch {
        return; // Self-healing: missing/unreadable dirs list as empty.
      }
      // Iterate in path-string order — directories key as "name/" so the DFS
      // emits exact global lexicographic order ("a.md" < "a/...", `.` < `/`).
      // The capped subset is deterministic across platforms.
      const sortKey = (entry: (typeof entries)[number]) =>
        entry.isDirectory() ? `${entry.name}/` : entry.name;
      entries.sort((a, b) => {
        const ka = sortKey(a);
        const kb = sortKey(b);
        return ka < kb ? -1 : ka > kb ? 1 : 0;
      });
      for (const entry of entries) {
        // Per-entry cap: a single flat directory can exceed the cap on its own.
        if (results.length > MEMORY_MAX_FILES_PER_SCOPE) return;
        if (entry.name.startsWith(".")) continue;
        const childRel = dirRel === "" ? entry.name : `${dirRel}/${entry.name}`;
        if (entry.isDirectory()) {
          await walk(childRel);
        } else if (entry.isFile()) {
          results.push(childRel);
        }
      }
    };
    await walk("");
    return results.sort();
  }

  async kind(relPath: string): Promise<MemoryEntryKind> {
    try {
      const stat = await fsPromises.stat(this.abs(relPath));