flowviant 0.116.0 → 0.124.0

package/bin/lib/repoState.mjs

@@ -31,29 +31,26 @@
  * repo mid-rebase or an unborn HEAD is a field to omit, not an error to raise.
  */
 
-import { execFileSync } from 'node:child_process';
 import { measureListeners, listenersSupported } from './listeners.mjs';
+import { git, GIT_WIDE_BUFFER, isSessionBranch } from './git.mjs';
 
 /** Same cap the session diffstat uses: enough to see the shape, small enough
  *  that one machine cannot flood a row. */
 const MAX_BRANCHES = 60;
 const MAX_WORKTREES = 40;
 
-function git(args, cwd) {
-  return execFileSync('git', args, {
-    cwd,
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'ignore'],
-    timeout: 10_000,
-    maxBuffer: 8 * 1024 * 1024,
-  }).trim();
-}
+/** Every read here is BOUNDED and QUIET: a best-effort report in the poll
+ *  loop must neither hold the event loop on a wedged git nor print git's
+ *  complaints about a repo mid-rebase onto the daemon's terminal. git.mjs's
+ *  own `git()`, with those options (audit 2026-10-10, F107) — this module
+ *  used to declare a private `function git` of the same name with different
+ *  semantics, so a reader could not tell which one a call meant. */
+const READ = Object.freeze({ timeout: 10_000, maxBuffer: GIT_WIDE_BUFFER, stdio: ['ignore', 'pipe', 'ignore'] });
 
-/** A ref Flowviant itself cut for a tab. The ONLY thing that makes a branch
- *  "ours", and the distinction the whole report exists to draw. */
-export function isSessionBranch(name) {
-  return /^session\//.test(name);
-}
+/** A ref Flowviant itself cut for a tab — the distinction the whole report
+ *  exists to draw. Defined beside the branch-name writer in git.mjs (audit
+ *  2026-10-10, F122) and re-exported here for this report's readers. */
+export { isSessionBranch };
 
 /**
  * `git worktree list --porcelain` → rows. The porcelain form is parsed rather
@@ -63,7 +60,7 @@ export function isSessionBranch(name) {
 function readWorktrees(repoRoot) {
   let out;
   try {
-    out = git(['worktree', 'list', '--porcelain'], repoRoot);
+    out = git(['worktree', 'list', '--porcelain'], repoRoot, READ);
   } catch {
     return null; // not a git repo, or git is unhappy — say nothing
   }
@@ -103,13 +100,14 @@ function readBranches(repoRoot, baseRef) {
   const fmt = '%(refname:short)%09%(committerdate:unix)%09%(ahead-behind:' + baseRef + ')';
   let out;
   try {
-    out = git(['for-each-ref', '--sort=-committerdate', `--format=${fmt}`, 'refs/heads'], repoRoot);
+    out = git(['for-each-ref', '--sort=-committerdate', `--format=${fmt}`, 'refs/heads'], repoRoot, READ);
   } catch {
     // No ahead-behind on this git. Names and dates still answer most of it.
     try {
       out = git(
         ['for-each-ref', '--sort=-committerdate', '--format=%(refname:short)%09%(committerdate:unix)', 'refs/heads'],
-        repoRoot
+        repoRoot,
+        READ
       );
     } catch {
       return null;
@@ -146,7 +144,7 @@ export function repoState(repoRoot, baseRef) {
   /**
    * WHAT IS LISTENING IN THE CHECKOUT ITSELF.
    *
-   * `listenersIn` has always taken any directory, and had only ever been asked
+   * `measureListeners` has always taken any directory, and had only ever been asked
    * about SESSION WORKTREES — so somebody running `npm run dev` in their normal
    * checkout, which is what "just testing or playing around in dev" actually
    * looks like, was invisible to every surface in the product. The measurement

package/bin/lib/repositoryBaseline.mjs

@@ -0,0 +1,68 @@
+/** Point-in-time repository facts. Reads only; never refreshes a worktree. */
+import { git } from './git.mjs';
+import { scrubCut } from './uplinkScrub.mjs';
+
+const sha = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
+export function measureRepositoryBaseline({ cwd, baseRef, knowledgeDir = null, readGit = git }) {
+  const opts = { timeout: 5000, maxBuffer: 128 * 1024, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' }, stdio: ['ignore', 'pipe', 'pipe'] };
+  const read = (args, convert, category = 'read_failed') => {
+    try { return { state: 'measured', value: convert(readGit(args, cwd, opts)) }; }
+    catch (e) { return { state: 'error', errorCategory: e?.code === 'ENOENT' ? 'git_unavailable' : e?.code === 'ENOBUFS' ? 'bounded' : category }; }
+  };
+  const commit = s => { if (!sha.test(s)) throw new Error('unresolved ref'); return s; };
+  let ref;
+  let refFailed = false;
+  try { ref = typeof baseRef === 'function' ? baseRef() : baseRef; } catch { refFailed = true; }
+  const head = read(['rev-parse', '--verify', 'HEAD'], commit, 'unresolved_ref');
+  const base = typeof ref === 'string' && ref ? read(['rev-parse', '--verify', '--end-of-options', `${ref}^{commit}`], commit, 'unresolved_ref') : refFailed ? { state: 'error', errorCategory: 'read_failed' } : { state: 'unknown' };
+  const dirty = read(['status', '--porcelain=v1', '-z', '--untracked-files=normal'], s => s.length > 0);
+  const shallow = read(['rev-parse', '--is-shallow-repository'], s => { if (s !== 'true' && s !== 'false') throw new Error('unknown'); return s === 'true'; });
+  let relation = 'unknown';
+  if (head.state === 'measured' && base.state === 'measured') {
+    if (head.value === base.value) relation = 'same';
+    else {
+      const ancestor = (a, b) => {
+        try { readGit(['merge-base', '--is-ancestor', a, b], cwd, opts); return true; }
+        catch (e) { return e?.status === 1 ? false : null; }
+      };
+      const behind = ancestor(head.value, base.value);
+      const ahead = ancestor(base.value, head.value);
+      relation = behind === true ? 'behind' : ahead === true ? 'ahead' : behind === false && ahead === false && shallow.state === 'measured' && shallow.value === false ? 'diverged' : 'unknown';
+    }
+  }
+  return {
+    measuredAt: new Date().toISOString(), cwd: scrubCut(cwd, 500),
+    head, base: { ref: typeof ref === 'string' ? scrubCut(ref, 300) : null, head: base }, dirty, relation,
+    shallow,
+    knowledgeDir: knowledgeDir ? scrubCut(knowledgeDir, 500) : null,
+    historyComparison: { state: 'unknown' }, deployment: { state: 'unknown' },
+  };
+}
+
+/** Revalidate the report, never splice arbitrary wire prose into a system prompt. */
+export function repositoryBaselineOf(raw) {
+  if (!raw || typeof raw !== 'object' || typeof raw.cwd !== 'string' || typeof raw.measuredAt !== 'string') return null;
+  const field = (f, boolean = false) => {
+    if (f?.state === 'measured' && (boolean ? typeof f.value === 'boolean' : typeof f.value === 'string' && sha.test(f.value))) return { state: 'measured', value: f.value };
+    if (f?.state === 'error') return { state: 'error', errorCategory: ['git_unavailable', 'unresolved_ref', 'read_failed', 'bounded'].includes(f.errorCategory) ? f.errorCategory : 'read_failed' };
+    return { state: 'unknown' };
+  };
+  return {
+    cwd: scrubCut(raw.cwd, 500), measuredAt: scrubCut(raw.measuredAt, 40),
+    head: field(raw.head), base: { ref: typeof raw.base?.ref === 'string' ? scrubCut(raw.base.ref, 300) : null, head: field(raw.base?.head) },
+    dirty: field(raw.dirty, true), shallow: field(raw.shallow, true),
+    relation: ['same', 'behind', 'ahead', 'diverged'].includes(raw.relation) ? raw.relation : 'unknown',
+    knowledgeDir: typeof raw.knowledgeDir === 'string' ? scrubCut(raw.knowledgeDir, 500) : null,
+    historyComparison: { state: 'unknown' }, deployment: { state: 'unknown' },
+  };
+}
+
+export function compareRepositoryBaselines(planner, capture) {
+  const head = planner.head.state === 'measured' && capture?.head.state === 'measured'
+    ? planner.head.value === capture.head.value ? 'same' : 'different' : 'unknown';
+  const cwd = capture ? planner.cwd === capture.cwd ? 'same' : 'different' : 'unknown';
+  const dirty = planner.dirty.state === 'measured' && capture?.dirty.state === 'measured'
+    ? planner.dirty.value || capture.dirty.value ? 'dirty' : 'clean' : 'unknown';
+  return { head, cwd, dirty, execution: planner.relation,
+    reconciliation: head === 'different' || dirty === 'dirty' || ['behind', 'ahead', 'diverged'].includes(planner.relation) ? 'required' : head === 'unknown' || dirty === 'unknown' ? 'unverified' : 'aligned' };
+}