Function makeMemFs

src/commands/agent.test.ts:20–91

()

// ---------------------------------------------------------------------------

function makeMemFs(): {
  store: Map<string, string>;
  fs: AgentFs;
  mkdirCalls: string[];
  writeCalls: string[];
  seedFile: (p: string, content: string) => void;
  seedDir: (p: string) => void;
  seedSymlink: (p: string) => void;
} {
  const store = new Map<string, string>(); // regular files: path -> content
  const dirs = new Set<string>(); // directories
  const symlinks = new Set<string>(); // symlinks (we only need to know it IS one)
  const mkdirCalls: string[] = [];
  const writeCalls: string[] = [];

  // Record `p` and all of its ancestors as directories, modelling a real fs
  // tree so the per-component lstat walk in inspectTargetPath can traverse.
  const addAncestorDirs = (p: string) => {
    let cur = path.dirname(p);
    while (cur !== path.dirname(cur)) {
      dirs.add(cur);
      cur = path.dirname(cur);
    }
    dirs.add(cur); // filesystem root
  };

  const agentFs: AgentFs = {
    async lstat(p: string) {
      if (symlinks.has(p)) return { isFile: false, isSymbolicLink: true };
      if (store.has(p)) return { isFile: true, isSymbolicLink: false };
      if (dirs.has(p)) return { isFile: false, isSymbolicLink: false };
      return null;
    },
    async readFile(p: string) {
      const v = store.get(p);
      if (v === undefined) throw Object.assign(new Error(`ENOENT: ${p}`), { code: 'ENOENT' });
      return v;
    },
    async writeFile(p: string, data: string, opts?: { exclusive?: boolean }) {
      if (opts?.exclusive && (store.has(p) || dirs.has(p) || symlinks.has(p))) {
        throw Object.assign(new Error(`EEXIST: ${p}`), { code: 'EEXIST' });
      }
      writeCalls.push(p);
      store.set(p, data);
      addAncestorDirs(p);
    },
    async mkdir(p: string) {
      mkdirCalls.push(p);
      dirs.add(p);
      addAncestorDirs(p);
    },
  };

  return {
    store,
    fs: agentFs,
    mkdirCalls,
    writeCalls,