omp-conductor 0.3.3 → 0.3.5

package/src/types.ts

@@ -46,6 +46,31 @@ export interface RepoTarget {
    * subset lets lint errors outside the source dir reach the runners.
    */
   gates: { cmd: string; cwd: string }[];
+  /**
+   * Absolute path of the **conductor-owned, index-only clone** of this repo
+   * whose code-graph index workers query. Optional: absent means this repo has
+   * no graph, and the worker brief says nothing about one.
+   *
+   * Two things it deliberately is not, and both were paid for:
+   *
+   * - **Not a worker's worktree.** A code-graph index is keyed by the realpath
+   *   of the directory it was built from, with no git-worktree awareness, so a
+   *   run's throwaway `worktrees/<issue>` path is always an empty project. A
+   *   worker that queried its own cwd would find nothing, conclude there is no
+   *   graph, and go back to grepping — which is the entire cost this field
+   *   exists to remove.
+   * - **Not a human's checkout.** Refreshing an index means hard-resetting the
+   *   clone to its default branch. Doing that where somebody works destroys
+   *   their uncommitted edits; making it safe instead (a fast-forward pull)
+   *   means the graph reflects whatever feature branch they left checked out.
+   *   So this names a disposable clone nothing human ever edits, which is what
+   *   makes the reset both safe and deterministic.
+   *
+   * `omp-conductor graph-setup` prints how to create and refresh it. Nothing in
+   * this package reads an index itself: the daemon only passes this path into
+   * the worker brief.
+   */
+  graphProject?: string;
 }
 
 /**

package/src/worktree.ts

@@ -8,8 +8,8 @@
  * for the delta.
  */
 
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 
 import type { RepoTarget } from "./types.ts";
 
@@ -96,6 +96,50 @@ async function gitSucceeds(args: string[], cwd?: string): Promise<boolean> {
   return code === 0;
 }
 
+/** Fences the block below so it can be found, replaced, and never duplicated. */
+const EXCLUDE_BEGIN = "# >>> omp-conductor (managed; edit outside this block)";
+const EXCLUDE_END = "# <<< omp-conductor";
+
+/**
+ * Appended to every mirror's `info/exclude`, and so in force in every worktree
+ * cut from it. Deliberately the same shapes salvage therefore skips, and
+ * for the same reason — a worker's own scaffolding is not the repo's business.
+ *
+ * Two layers because they catch different moments: this one keeps scratch out
+ * of a worker's own `git add -A` and out of its `git status`, which salvage
+ * never observes; the salvage list catches whatever a worker created before
+ * this landed, or wrote past an ignore with `add -f`.
+ */
+const LOCAL_EXCLUDE = [".scratch*/", ".scratch*", ".env.local", "*.local.sh"];
+
+/**
+ * Adds the managed block to an `info/exclude`, preserving everything else.
+ *
+ * `info/exclude` is a *local* ignore file, which means it is exactly where an
+ * operator or another tool puts patterns they could not put in the tracked
+ * `.gitignore` — so overwriting it would silently destroy work that has no
+ * other copy. The block is fenced and replaced in place, so re-running this on
+ * every dispatch neither duplicates our lines nor disturbs theirs.
+ */
+export function mergeExclude(existing: string): string {
+  const begin = existing.indexOf(EXCLUDE_BEGIN);
+  const end = existing.indexOf(EXCLUDE_END);
+  const theirs =
+    begin === -1 || end === -1 || end < begin
+      ? existing
+      : existing.slice(0, begin) + existing.slice(end + EXCLUDE_END.length + 1);
+
+  // Normalised before recomposing, so the result is byte-identical on every
+  // call. Trimming the tail matters twice over: a hand-edited file often has no
+  // trailing newline (the first managed line would glue onto their last
+  // pattern and match nothing), and without it the blank separator below would
+  // accumulate one more newline on each of the thousands of dispatches that
+  // call this.
+  const body = theirs.replace(/\n+$/, "");
+  const head = body === "" ? [] : [body, ""];
+  return [...head, EXCLUDE_BEGIN, ...LOCAL_EXCLUDE, EXCLUDE_END, ""].join("\n");
+}
+
 /**
  * Rewrites the two `clone --mirror` defaults that are actively dangerous for a
  * cache we cut worktrees from. Applied on every `ensureMirror` so a mirror left
@@ -122,6 +166,20 @@ async function configureMirror(mirrorPath: string): Promise<void> {
     ["config", "--replace-all", "remote.origin.fetch", TRACKING_REFSPEC],
     mirrorPath,
   );
+
+  // A mirror's `info/exclude` is the common git dir for every worktree cut from
+  // it, so one write here keeps a worker's own scratch out of `git status` in
+  // all of them — without touching the repo's tracked `.gitignore`, which is
+  // the operator's file and not ours to edit.
+  //
+  // Belt and braces with the salvage excludes rather than a replacement for
+  // them: this stops scratch reaching a *worker's* own `git add`, which salvage
+  // never sees. Merged rather than written, because `info/exclude` is precisely
+  // where an operator keeps patterns that cannot go in the tracked file — and
+  // this runs on every dispatch, so overwriting would destroy them repeatedly.
+  const exclude = join(mirrorPath, "info", "exclude");
+  mkdirSync(dirname(exclude), { recursive: true });
+  writeFileSync(exclude, mergeExclude(existsSync(exclude) ? readFileSync(exclude, "utf8") : ""));
 }
 
 /**
@@ -343,7 +401,28 @@ export async function salvageWip(
     const branch = await git(["rev-parse", "--abbrev-ref", "HEAD"], worktree);
 
     // `-A` on purpose: the losses this exists for were mostly *new* files.
+    //
+    // Filtering scratch is git's job, not a pathspec's. The mirror's
+    // `info/exclude` (see {@link mergeExclude}) is the common git dir for this
+    // worktree, and git's own rules then give exactly the semantics needed:
+    // untracked ignored files are skipped, while modifications to *tracked*
+    // files are staged even when the name matches an ignore. That second half
+    // is why an exclude pathspec here was wrong — it matched on filename alone,
+    // so a repo legitimately versioning a `bootstrap.local.sh` would have lost
+    // a worker's edits to it, salvage destroying the work it exists to save.
+    //
+    // A literal `:(exclude)<path>` was also an outright bug: git counts it as
+    // naming the path, so an already-ignored file made `add` exit 1 and every
+    // cap-kill would have reported a salvage *failure*.
     await git(["add", "-A"], worktree);
+
+    // The dirty check above ran before git applied its ignores, so a tree whose
+    // only changes were ignored scratch had work by that test and none by this.
+    // Without this, `commit` exits non-zero on an empty index and a tree
+    // holding nothing worth keeping gets reported as a salvage *failure*.
+    if ((await git(["diff", "--cached", "--name-only"], worktree)) === "") {
+      return { kind: "nothing" };
+    }
     await git(
       [
         ...SALVAGE_COMMIT_CONFIG,