typescript-namespace-git-init

Answer

Root cause (DOGFOOD-005): git init lived inside immediateCommit, which was only invoked from the 30s unref()'d debounce timer callback. Implicit namespace creation (CLI remember / REST POST without create_namespace) wrote the dir + JSONL immediately, but the timer never fired in a short-lived CLI process — so .git was never created and snapshots were silently unversioned.

Fix (two parts): 1. commitNamespaceWithParams() checks for a missing .git on first write and runs immediateCommit (git init + local identity + add + commit) synchronously — awaited inline instead of deferred to the timer. Later writes still batch into the 30s debounced commit. 2. process.on('exit', flushAllCommits) flushes still-pending debounced commits on CLI exit (synchronous spawnSync core, since exit handlers can't await).

// namespace-git.ts (fix core)
export const DEBOUNCE_MS = 30_000;
export const COMMIT_IDENTITY = Object.freeze({ name: 'pi-namespace-bot', email: 'pi-namespace-bot@localhost' });

const hasGitDir = (dir: string) => existsSync(join(dir, '.git'));

async function ensureGitRepo(dir: string): Promise<void> {
  if (hasGitDir(dir)) return;                                   // idempotent
  await gitAsync(['init', '-q'], dir);
  await gitAsync(['config', 'user.name', COMMIT_IDENTITY.name], dir);   // local identity:
  await gitAsync(['config', 'user.email', COMMIT_IDENTITY.email], dir); // commits never fail w/o global config
}

async function commitNow(namespace: string, entry: PendingCommit): Promise<void> {
  const paths = [...entry.paths];
  if (paths.length === 0) return;                               // never create empty commits
  await ensureGitRepo(entry.dir);
  await gitAsync(['add', '--', ...paths], entry.dir);
  await gitAsync(['commit', '-q', '-m', `namespace ${namespace}: snapshot`], entry.dir);
  entry.paths.clear();
  if (entry.timer) { clearTimeout(entry.timer); entry.timer = null; }
}

function scheduleDebounced(namespace: string, entry: PendingCommit): void {
  if (entry.timer) clearTimeout(entry.timer);
  entry.timer = setTimeout(() => { entry.timer = null; void flushCommit(namespace, entry); }, DEBOUNCE_MS);
  entry.timer.unref();                                          // must not hold a server process open
}

export async function commitNamespaceWithParams(params: CommitParams): Promise<void> {
  const { namespace, dir, paths } = params;
  let entry = pending.get(namespace);
  if (!entry) {
    entry = { dir, paths: new Set(), timer: null, initialized: hasGitDir(dir), committing: null };
    pending.set(namespace, entry);
  }
  for (const p of paths) entry.paths.add(p);

  if (!entry.initialized) {
    // DOGFOOD-005: first write to a namespace w/o .git -> init+identity+add+commit NOW.
    await flushCommit(namespace, entry);                        // synchronous from caller's perspective
    entry.initialized = true;
    return;
  }
  scheduleDebounced(namespace, entry);                          // later writes: batching preserved
}

export async function flushAllCommits(): Promise<void> { /* async, shutdown/tests */ }

export function flushAllCommitsSync(): void {                   // exit-handler core: spawnSync
  for (const [ns, entry] of pending) {
    if (entry.timer) { clearTimeout(entry.timer); entry.timer = null; }
    if (entry.paths.size === 0 || entry.committing) continue;
    try { commitNowSync(ns, entry); }
    catch (err) { console.error(`namespace-git: exit flush failed for ${ns}:`, err); } // never throw on exit
  }
}

process.on('exit', flushAllCommitsSync);   // DOGFOOD-005: flush pending debounced commits on CLI exit

A per-namespace committing promise guard prevents concurrent first-write bursts (REST) from double-committing; flushAllCommitsSync skips entries with a commit in flight so exit never double-commits.