chord-cli 0.2.0 → 0.2.1

package/dist/tools.js

@@ -1,40 +1,47 @@
-import { execFileSync, execSync } from 'node:child_process';
+import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import * as db from "./db.js";
-import { readConfig } from "./launch.js";
+/** path.relative, except that on macOS directory names differing only in case match, as path.relative already has them
+ *  on Windows: both file systems ignore case, so /P/Repo is /P/repo, and a write must not slip past a check that way. */
+function relativePath(from, to) {
+    if (process.platform !== 'darwin')
+        return path.relative(from, to);
+    const a = path.resolve(from).split('/').filter(Boolean), b = path.resolve(to).split('/').filter(Boolean);
+    let i = 0;
+    while (i < a.length && i < b.length && a[i].toLowerCase() === b[i].toLowerCase())
+        i++;
+    return [...a.slice(i).map(() => '..'), ...b.slice(i)].join('/');
+}
 /** Is `file` inside `dir`? False for paths on another drive or above it. */
 export function insideDir(dir, file) {
-    const rel = path.relative(dir, path.resolve(dir, file));
+    const rel = relativePath(dir, path.resolve(dir, file));
     return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
 }
 /**
- * The claim key for a path an agent names: workspace-relative with forward slashes. Absolute paths and
- * paths starting with the repository directory are taken as given; a path from the project folder
- * (chord/agents/<name>/<repo>/...) is resolved there; any other relative path is read as
- * repository-relative (what agents working inside the repo naturally write). Paths outside the
+ * The claim key for a path an agent names: workspace-relative with forward slashes. Absolute paths are taken as
+ * given; a path from the project folder (chord/agents/<name>/<repo>/...) is resolved there; any other relative
+ * path is repository-relative (what agents working on the repository naturally write). Paths outside the
  * workspace are refused: chord cannot coordinate them.
  */
 export function claimPath(ctx, file) {
-    const repoDir = path.relative(ctx.cwd, ctx.worktree).split(path.sep).join('/');
     const asGiven = normFile(ctx, file);
     let abs;
     const fromProject = 'chord/agents/'; // the spelling from the tool's cwd, the project folder; another agent's folder then fails the check below
-    if (path.isAbsolute(file) || !repoDir || repoDir === '.' || /^\.\.(\/|$)/.test(asGiven))
+    if (path.isAbsolute(file) || /^\.\.(\/|$)/.test(asGiven))
         abs = path.resolve(ctx.cwd, file);
     else if (ctx.project && asGiven.startsWith(fromProject))
         abs = path.resolve(ctx.project, file);
-    else if (asGiven === repoDir || asGiven.startsWith(repoDir + '/')) {
-        // "rich/console.py" is the workspace path of the repository's console.py, or the repository path of a package
-        // named like the repository (rich/rich/console.py); whichever exists is meant, and both existing is ambiguous
-        const asWorkspace = path.resolve(ctx.cwd, file), asRepo = path.resolve(ctx.worktree, file);
-        const w = fs.existsSync(asWorkspace), r = fs.existsSync(asRepo);
-        if (w && r && asWorkspace !== asRepo)
-            throw new Error(`${file} is ambiguous: it could be ${normFile(ctx, asWorkspace)} or ${normFile(ctx, asRepo)}; give the path from your workspace root`);
-        abs = r && !w ? asRepo : asWorkspace;
-    }
-    else
+    else {
         abs = path.resolve(ctx.worktree, file);
+        // From the project folder "<repo>/x" is the main checkout's x. An agent naming its own copy that way, where the
+        // repository has no such path but x exists at its root, is told the spellings that reach it rather than given a
+        // claim on a file that is not there.
+        const repoName = path.basename(ctx.worktree), inner = asGiven.slice(repoName.length + 1);
+        if (asGiven.startsWith(`${repoName}/`) && !fs.existsSync(abs) && fs.existsSync(path.resolve(ctx.worktree, inner))) {
+            throw new Error(`there is no ${asGiven} in the repository, but it has ${inner}: name files relative to the repository root ("${inner}") or from the project folder ("chord/agents/<you>/${repoName}/${inner}")`);
+        }
+    }
     if (!insideDir(ctx.cwd, abs))
         throw new Error(`${file} is outside your workspace; chord only coordinates files under ${ctx.cwd}`);
     return normFile(ctx, abs);
@@ -42,7 +49,7 @@ export function claimPath(ctx, file) {
 /** How long a latecomer waits for replies before it may write anyway. */
 export const REPLY_TIMEOUT_MS = 10 * 60 * 1000;
 /** How long before its claim a latecomer's message to an occupant still counts as asking about that file. */
-export const ASK_WINDOW_MS = 2 * 60 * 1000;
+const ASK_WINDOW_MS = 2 * 60 * 1000;
 const str = (desc) => ({ type: 'string', description: desc });
 function req(args, key) {
     const v = args[key];
@@ -50,9 +57,9 @@ function req(args, key) {
         throw new Error(`${key} is required`);
     return v;
 }
-/** Worktree-relative path with forward slashes, so the same file matches across worktrees. */
+/** Workspace-relative path with forward slashes (repo/src/x.ts), so the same file matches across agents' worktrees. */
 export function normFile(ctx, file) {
-    return path.relative(ctx.cwd, path.resolve(ctx.cwd, file)).split(path.sep).join('/');
+    return relativePath(ctx.cwd, path.resolve(ctx.cwd, file)).split(path.sep).join('/');
 }
 export function peers(ctx) {
     return db.listAgents(ctx.db).filter(a => a.name !== ctx.agent).map(a => ({
@@ -61,10 +68,11 @@ export function peers(ctx) {
 }
 // words that describe code rather than name it: "the parse function" and "parse tests" share only "parse"
 const NOT_SYMBOLS = new Set(['a', 'an', 'and', 'or', 'the', 'of', 'in', 'to', 'for', 'with', 'new', 'its', 'all', 'function', 'functions', 'method', 'methods', 'class', 'classes', 'test', 'tests', 'block', 'blocks', 'section', 'line', 'lines', 'file', 'helper', 'helpers', 'code', 'logic', 'docs', 'docstring']);
-const symbolSet = (s) => new Set((s ?? '').toLowerCase().match(/[a-z_$][\w$.]*/g)?.filter(w => !NOT_SYMBOLS.has(w)) ?? []);
+// "Parser.parse" names Parser and parse too: whoever holds either holds part of it
+const symbolSet = (s) => new Set((s ?? '').toLowerCase().match(/[a-z_$][\w$.]*/g)?.flatMap(w => [w, ...w.split('.')]).filter(w => w && !NOT_SYMBOLS.has(w)) ?? []);
 /** Two modify claims on one file that each name the functions or blocks they touch, with none in common, do not
  *  need to talk first. Anything less certain (no symbols on either side, or an add, delete or rename) does. */
-export function disjointEdits(a, b) {
+function disjointEdits(a, b) {
     if (a.kind !== 'modify' || b.kind !== 'modify')
         return false;
     const x = symbolSet(a.symbols), y = symbolSet(b.symbols);
@@ -73,7 +81,9 @@ export function disjointEdits(a, b) {
 /** Online agents who claimed `file` before `mine` did, split into those `mine` overlaps and must talk to and those
  *  editing other parts of it. */
 function earlierOccupants(ctx, mine) {
-    const before = (c) => c.created_at < mine.created_at || (c.created_at === mine.created_at && c.rid < mine.rid);
+    // by rowid, which the insert gets under the write lock, not by the timestamp read before waiting for it: two
+    // agents claiming at once would otherwise each see the other as later and neither would talk first
+    const before = (c) => c.rid < mine.rid;
     const all = db.claimsFor(ctx.db, mine.file).filter(c => c.agent !== ctx.agent && before(c) && db.getAgent(ctx.db, c.agent)?.status !== 'offline');
     return { overlap: all.filter(c => !disjointEdits(c, mine)), elsewhere: all.filter(c => disjointEdits(c, mine)) };
 }
@@ -103,7 +113,7 @@ export function canWrite(ctx, file, now = Date.now()) {
         const askedAt = db.firstMessageAt(ctx.db, ctx.agent, o.agent, Math.max(since, mine.created_at - ASK_WINDOW_MS));
         if (askedAt === null)
             notAsked.push(o.agent);
-        else if (!db.repliedSince(ctx.db, o.agent, ctx.agent, since) && now - askedAt < REPLY_TIMEOUT_MS)
+        else if (db.firstMessageAt(ctx.db, o.agent, ctx.agent, since) === null && now - askedAt < REPLY_TIMEOUT_MS)
             waiting.push({ agent: o.agent, left: REPLY_TIMEOUT_MS - (now - askedAt) });
     }
     if (notAsked.length) {
@@ -115,9 +125,7 @@ export function canWrite(ctx, file, now = Date.now()) {
     }
     return { ok: true };
 }
-// 64 MB of output: a project's post-merge hook may print a great deal, and the default 1 MB would turn a merge that
-// already happened into an exception
-const git = (cwd, ...args) => execFileSync('git', args, { cwd, encoding: 'utf8', env: db.gitEnv(), stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024 }).trim();
+const { git } = db;
 const gitOk = (cwd, ...args) => { try {
     git(cwd, ...args);
     return true;
@@ -126,7 +134,7 @@ catch {
     return false;
 } };
 const stderrOf = (e) => (e.stderr ?? e.message).trim();
-const sleepSync = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+const { sleepSync } = db;
 /** Tracked files with real changes, staged or not, ignoring line-ending differences and whatever happens inside
  *  submodules; '' when clean. */
 export function dirtyTracked(cwd) {
@@ -148,8 +156,10 @@ function gitRetry(cwd, ...args) {
         }
     }
 }
-/** Run fn holding an exclusive lock file. Waits up to `waitMs`; a lock older than `staleMs` is taken over. */
-export function withLock(file, fn, waitMs = 240_000, staleMs = 180_000) {
+/** Run fn holding an exclusive lock file that names its holder's pid. Waits up to `waitMs`. A lock whose holder is
+ *  gone is taken over at once; one older than `staleMs` as well, which must exceed the longest run of the project's
+ *  test command (ten minutes) so a live holder is never robbed of its lock. */
+export function withLock(file, fn, waitMs = 240_000, staleMs = 15 * 60_000) {
     const t0 = Date.now();
     for (;;) {
         try {
@@ -160,7 +170,8 @@ export function withLock(file, fn, waitMs = 240_000, staleMs = 180_000) {
             if (e.code !== 'EEXIST')
                 throw e;
             try {
-                if (Date.now() - fs.statSync(file).mtimeMs > staleMs) {
+                const holder = Number(fs.readFileSync(file, 'utf8'));
+                if ((holder > 0 && !db.pidAlive(holder)) || Date.now() - fs.statSync(file).mtimeMs > staleMs) {
                     fs.unlinkSync(file);
                     continue;
                 }
@@ -173,16 +184,50 @@ export function withLock(file, fn, waitMs = 240_000, staleMs = 180_000) {
             sleepSync(150 + Math.random() * 200);
         }
     }
+    // only our own lock is removed: one taken over meanwhile belongs to whoever holds it now
     try {
         return fn();
     }
     finally {
         try {
-            fs.unlinkSync(file);
+            if (fs.readFileSync(file, 'utf8') === String(process.pid))
+                fs.unlinkSync(file);
         }
         catch { /* already gone */ }
     }
 }
+/** <project>/chord/config.json. `setup` is a shell command run in every new worktree before the agent starts,
+ *  for example "npm install". `test` is a shell command finish runs in the worktree after rebasing onto main and
+ *  before fast-forwarding it, for example "npm test"; when it fails nothing is merged. Lives here, not in launch.ts,
+ *  so the hooks (which load this module for finish's sake) do not load the launch code on every tool call. */
+export function readConfig(project) {
+    const file = path.join(project.dir, 'chord', 'config.json');
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return {};
+    }
+    let cfg;
+    try {
+        cfg = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`${file} is not valid JSON: ${e.message}`);
+    }
+    if (typeof cfg !== 'object' || cfg === null)
+        throw new Error(`${file} must hold a JSON object`);
+    const out = {};
+    for (const key of ['setup', 'test']) {
+        const v = cfg[key];
+        if (v !== undefined && typeof v !== 'string')
+            throw new Error(`${file}: "${key}" must be a string (a shell command)`);
+        if (v)
+            out[key] = v;
+    }
+    return out;
+}
 /** Rebase the agent's branch onto main and fast-forward main to it. Atomic from the agent's point of view.
  *  Finishes are serialised with a lock file: git cannot run two merges in one checkout concurrently. */
 export function finish(ctx) {
@@ -193,9 +238,9 @@ function finishLocked(ctx) {
     const wt = ctx.worktree;
     // A rebase in progress is only ours to clean up when finish itself started it (a finish killed mid-rebase leaves
     // the marker behind). Anyone else's rebase, perhaps with conflicts already resolved, is left alone.
-    const marker = path.resolve(wt, git(wt, 'rev-parse', '--git-path', 'chord-finish'));
-    for (const dir of ['rebase-merge', 'rebase-apply']) {
-        if (!fs.existsSync(path.resolve(wt, git(wt, 'rev-parse', '--git-path', dir))))
+    const [marker, rebaseMerge, rebaseApply, indexLock] = git(wt, 'rev-parse', '--git-path', 'chord-finish', '--git-path', 'rebase-merge', '--git-path', 'rebase-apply', '--git-path', 'index.lock').split('\n').map(p => path.resolve(wt, p));
+    for (const dir of [rebaseMerge, rebaseApply]) {
+        if (!fs.existsSync(dir))
             continue;
         if (!fs.existsSync(marker))
             throw new Error('a rebase is in progress in your worktree that finish did not start; run `git rebase --continue` (after resolving conflicts) or `git rebase --abort` first');
@@ -204,7 +249,6 @@ function finishLocked(ctx) {
     }
     fs.rmSync(marker, { force: true });
     // a finish killed mid-operation can leave the worktree's own index.lock behind; one older than a minute is debris
-    const indexLock = path.resolve(wt, git(wt, 'rev-parse', '--git-path', 'index.lock'));
     try {
         if (Date.now() - fs.statSync(indexLock).mtimeMs > 60_000) {
             fs.unlinkSync(indexLock);
@@ -217,6 +261,12 @@ function finishLocked(ctx) {
     // such file as modified the moment it is checked out, and no agent can commit that away.
     if (dirtyTracked(wt))
         throw new Error('your worktree has uncommitted changes to tracked files; commit them first');
+    // Except the files this agent claimed: one it wrote and never added (git commit -a skips new files) would leave
+    // main with half the change, and the claim that protected it would be released below.
+    const claimed = db.claimsBy(ctx.db, ctx.agent).map(c => relativePath(wt, path.resolve(ctx.cwd, c.file)).split(path.sep).join('/')).filter(f => f && !f.startsWith('..'));
+    const lost = claimed.length ? git(wt, 'ls-files', '--others', '--exclude-standard', '--', ...claimed) : '';
+    if (lost)
+        throw new Error(`you claimed ${lost.split('\n').join(', ')} but never committed it: git add and commit it (or release the claim) and call finish again. Nothing was merged.`);
     // What status still reports now differs only in line endings. git will not rebase over it, and nothing done in a
     // worktree can clear it: the repository needs a renormalised commit, which is the user's call.
     const phantom = git(wt, 'status', '--porcelain', '--untracked-files=no', '--ignore-submodules=dirty').split('\n').filter(Boolean).map(l => l.replace(/^[ MADRCU?!]{1,2}\s+/, ''));
@@ -269,7 +319,7 @@ function finishLocked(ctx) {
     const subjects = git(root, 'log', '--format=%s', `${main}..${branch}`).split('\n').filter(Boolean);
     // A submodule commit the branch points at must exist in the main checkout's copy of the submodule, or the
     // fast-forward leaves main pointing at a commit that is nowhere but inside this agent's worktree.
-    for (const line of git(root, 'diff', '--raw', main, branch).split('\n')) {
+    for (const line of git(root, '-c', 'core.quotePath=false', 'diff', '--raw', main, branch).split('\n')) { // a non-ASCII path arrives as itself, not quoted and escaped
         const m = /^:\d{6} 160000 [0-9a-f]+ ([0-9a-f]+) [AM]\t(.+)$/.exec(line);
         if (!m)
             continue;
@@ -355,7 +405,6 @@ export function tools(ctx) {
                 db.addClaim(ctx.db, { agent: ctx.agent, file, intent: req(a, 'intent'), kind, symbols: typeof a.symbols === 'string' ? a.symbols : null });
                 const mine = db.claimsFor(ctx.db, file).find(c => c.agent === ctx.agent);
                 const { overlap: others, elsewhere } = earlierOccupants(ctx, mine);
-                db.log(`claim ${file} by ${ctx.agent} (cwd ${ctx.cwd}): rows=${JSON.stringify(db.claimsFor(ctx.db, file).map(c => [c.agent, c.created_at]))} agents=${JSON.stringify(db.listAgents(ctx.db).map(a => [a.name, a.status, a.pid]))} others=${others.map(o => o.agent)} elsewhere=${elsewhere.map(o => o.agent)}`);
                 const brief = (o) => ({ agent: o.agent, intent: o.intent, kind: o.kind, symbols: o.symbols });
                 return {
                     claimed: file,

package/dist/trust.js

@@ -3,7 +3,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-export const claudeConfigPath = () => path.join(os.homedir(), '.claude.json');
+const claudeConfigPath = () => path.join(os.homedir(), '.claude.json');
 // Claude Code keys projects by the cwd with forward slashes, even on Windows
 const norm = (p) => p.replace(/\\/g, '/').toLowerCase();
 /** Whether the user has answered yes to Claude Code's "do you trust this folder?" dialogue for `dir`. */
@@ -31,7 +31,7 @@ export function claudeMcpChoices(dir, file = claudeConfigPath()) {
         return { all: false, enabled: [], disabled: [] };
     }
 }
-export const codexConfigPath = () => path.join(os.homedir(), '.codex', 'config.toml');
+const codexConfigPath = () => path.join(os.homedir(), '.codex', 'config.toml');
 /** Codex keeps a trust hash and an on/off switch per hook in ~/.codex/config.toml. One keypress in its
  *  "Hooks need review" screen switches a hook off, and chord then silently loses the feature behind it, so
  *  chord names the switched-off hooks at launch. Returns Codex event names such as "session_start". */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chord-cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Run several coding agents in one git project, each in its own worktree, with shared file claims and messaging",
   "license": "MIT",
   "keywords": [
@@ -33,7 +33,8 @@
   },
   "os": [
     "win32",
-    "linux"
+    "linux",
+    "darwin"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json",