@switchyardhq/git-fleet 0.1.0

package/dist/lib/lines.js

@@ -0,0 +1,106 @@
+/**
+ * Line-range utilities for `fleet check --lines`: parse `git diff -U0` output
+ * into per-file ranges and intersect them across agents.
+ *
+ * All ranges are 1-indexed, inclusive, and expressed in *old-side* (merge-base)
+ * coordinates — the only coordinate system two agents' diffs share when both
+ * branched from the same base commit. When bases have diverged the ranges are
+ * a best-effort heuristic, which is why line-level checking is opt-in.
+ */
+/**
+ * Parse unified diff output (`git diff -U0`) into a map of file path (new
+ * side; old side for deletions) to edited old-side line ranges. A pure
+ * insertion (`-N,0`) is widened to [N, N+1] so that two agents inserting at
+ * the same spot still count as overlapping.
+ */
+export function parseUnifiedDiff(text) {
+    const result = new Map();
+    let current = null;
+    let aPath = null;
+    let headerPath = null;
+    const pathFrom = (raw) => {
+        const trimmed = raw.trim();
+        if (trimmed === '/dev/null')
+            return null;
+        return trimmed.replace(/^[ab]\//, '');
+    };
+    for (const line of text.split('\n')) {
+        const header = /^diff --git a\/(.*) b\//.exec(line);
+        if (header) {
+            current = null;
+            aPath = null;
+            headerPath = header[1] ?? null;
+            continue;
+        }
+        if (line.startsWith('--- ')) {
+            aPath = pathFrom(line.slice(4));
+            continue;
+        }
+        if (line.startsWith('+++ ')) {
+            current = pathFrom(line.slice(4)) ?? aPath;
+            if (current && !result.has(current))
+                result.set(current, []);
+            continue;
+        }
+        if (line.startsWith('Binary files ')) {
+            const file = current ?? headerPath;
+            if (file)
+                result.set(file, 'whole');
+            continue;
+        }
+        const hunk = /^@@ -(\d+)(?:,(\d+))? \+/.exec(line);
+        if (hunk && current) {
+            const entry = result.get(current);
+            if (!entry || entry === 'whole')
+                continue;
+            const start = Number(hunk[1]);
+            const count = hunk[2] === undefined ? 1 : Number(hunk[2]);
+            entry.push(count === 0 ? { start, end: start + 1 } : { start, end: start + count - 1 });
+        }
+    }
+    return result;
+}
+/** Sort and merge overlapping/adjacent ranges into a minimal list. */
+export function mergeRanges(ranges) {
+    const sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end);
+    const out = [];
+    for (const r of sorted) {
+        const last = out[out.length - 1];
+        if (last && r.start <= last.end + 1) {
+            last.end = Math.max(last.end, r.end);
+        }
+        else {
+            out.push({ ...r });
+        }
+    }
+    return out;
+}
+/**
+ * Intersect the edited ranges of several agents for one file.
+ * Returns 'whole' when any agent's line info is unknowable, otherwise the
+ * (possibly empty) union of pairwise intersections — empty means the agents
+ * edited disjoint lines.
+ */
+export function rangesOverlap(entries) {
+    if (entries.some((e) => e === 'whole'))
+        return 'whole';
+    const lists = entries;
+    const hits = [];
+    for (let i = 0; i < lists.length; i += 1) {
+        for (let j = i + 1; j < lists.length; j += 1) {
+            for (const a of lists[i] ?? []) {
+                for (const b of lists[j] ?? []) {
+                    const start = Math.max(a.start, b.start);
+                    const end = Math.min(a.end, b.end);
+                    if (start <= end)
+                        hits.push({ start, end });
+                }
+            }
+        }
+    }
+    return mergeRanges(hits);
+}
+/** "3-7, 12" style rendering for a range list. */
+export function formatRanges(ranges) {
+    return ranges.map((r) => (r.start === r.end ? `${r.start}` : `${r.start}-${r.end}`)).join(', ');
+}

package/dist/lib/proc.js

@@ -0,0 +1,42 @@
+import { spawn as spawnChild } from 'node:child_process';
+/**
+ * Run a shell command string in `cwd`, streaming its output to the terminal.
+ * Resolves with the exit code — a failing command is an expected outcome for
+ * callers (hooks, `fleet exec`), not an exception.
+ */
+export function runShell(command, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawnChild(command, { cwd, shell: true, stdio: 'inherit' });
+        child.on('error', reject);
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+}
+/**
+ * Run an executable with an argv array (no shell). Resolves with the exit
+ * code, or -1 when the executable could not be started at all (e.g. not on
+ * PATH) — callers turn that into a "not installed" message.
+ */
+export function runFile(file, args, cwd, opts = {}) {
+    return new Promise((resolve) => {
+        const child = spawnChild(file, args, {
+            cwd,
+            shell: false,
+            stdio: opts.quiet ? 'ignore' : 'inherit',
+        });
+        child.on('error', () => resolve(-1));
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+}
+// Tokens that survive both sh and cmd.exe without quoting.
+const SAFE_TOKEN = /^[A-Za-z0-9_\-./:=@,+]+$/;
+/**
+ * Join argv tokens back into one shell command line, quoting anything that
+ * needs it. A pragmatic heuristic that covers everyday commands on both sh
+ * and cmd.exe — not a full shell-escaping engine; genuinely exotic quoting
+ * belongs in a script file the command can call instead.
+ */
+export function shellJoin(tokens) {
+    return tokens
+        .map((t) => (SAFE_TOKEN.test(t) ? t : `"${t.replace(/"/g, '\\"')}"`))
+        .join(' ');
+}

package/dist/lib/state.js

@@ -0,0 +1,59 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { FleetError } from './errors.js';
+export function fleetDir(repoRoot) {
+    return path.join(repoRoot, '.fleet');
+}
+export function statePath(repoRoot) {
+    return path.join(fleetDir(repoRoot), 'state.json');
+}
+export function worktreesDir(repoRoot) {
+    return path.join(fleetDir(repoRoot), 'worktrees');
+}
+export function readState(repoRoot) {
+    const file = statePath(repoRoot);
+    if (!existsSync(file)) {
+        return { version: 1, agents: {} };
+    }
+    // Strip a UTF-8 BOM: Windows editors add one and JSON.parse rejects it.
+    const raw = readFileSync(file, 'utf8').replace(/^\uFEFF/, '');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        parsed = null;
+    }
+    if (parsed === null ||
+        typeof parsed !== 'object' ||
+        typeof parsed.agents !== 'object' ||
+        parsed.agents === null) {
+        throw new FleetError(`Switchyard state file is corrupted: ${file}\n` +
+            'Fix or delete it, then re-run. Your worktrees and branches are not affected; ' +
+            'you may need to `fleet spawn` agents again to re-register them.');
+    }
+    return parsed;
+}
+export function writeState(repoRoot, state) {
+    mkdirSync(fleetDir(repoRoot), { recursive: true });
+    const file = statePath(repoRoot);
+    // Write-then-rename so a crash mid-write never leaves a half-written state file.
+    const tmpFile = `${file}.tmp`;
+    writeFileSync(tmpFile, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+    renameSync(tmpFile, file);
+}
+/** Look up an agent by name, with a helpful error listing known agents. */
+export function getAgent(state, name) {
+    const record = state.agents[name];
+    if (!record) {
+        const known = Object.keys(state.agents).sort();
+        const hint = known.length > 0
+            ? `Known agents: ${known.join(', ')}.`
+            : 'No agents are registered. Run `fleet spawn <name>` to create one.';
+        throw new FleetError(`No agent named "${name}". ${hint}`);
+    }
+    return record;
+}
+export function worktreeAbsPath(repoRoot, record) {
+    return path.resolve(repoRoot, record.worktreePath);
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@switchyardhq/git-fleet",
+  "version": "0.1.0",
+  "description": "Manage multiple AI coding agents working on the same git repository: isolated worktrees per agent, collision detection before merge, safe cleanup.",
+  "keywords": [
+    "git",
+    "worktree",
+    "ai-agents",
+    "claude-code",
+    "codex",
+    "cursor",
+    "cli",
+    "developer-tools"
+  ],
+  "license": "MIT",
+  "author": "Mohammed Alkindi <alkndymhmd692@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MohammedAlkindi/Switchyard.git"
+  },
+  "bugs": "https://github.com/MohammedAlkindi/Switchyard/issues",
+  "homepage": "https://github.com/MohammedAlkindi/Switchyard#readme",
+  "type": "module",
+  "bin": {
+    "fleet": "dist/cli.js"
+  },
+  "main": "dist/cli.js",
+  "files": [
+    "dist",
+    "schema"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run lint && npm run typecheck && npm test"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "simple-git": "^3.27.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.9.0",
+    "@types/node": "^22.5.0",
+    "@types/tmp": "^0.2.6",
+    "@vitest/coverage-v8": "^2.1.9",
+    "eslint": "^9.9.0",
+    "tmp": "^0.2.3",
+    "typescript": "^5.5.4",
+    "typescript-eslint": "^8.2.0",
+    "vitest": "^2.1.0"
+  }
+}

package/schema/fleetrc.schema.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://unpkg.com/@switchyardhq/git-fleet/schema/fleetrc.schema.json",
+  "title": ".fleetrc.json",
+  "description": "Per-repo defaults for Switchyard (@switchyardhq/git-fleet). Precedence everywhere: CLI flag > .fleetrc.json > built-in default.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "Pointer to this schema, for editor autocomplete and validation."
+    },
+    "defaultBase": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Default base branch for `fleet spawn` when --from is not passed (built-in default: the current branch)."
+    },
+    "watchInterval": {
+      "type": "number",
+      "exclusiveMinimum": 0,
+      "description": "Default refresh interval for `fleet watch`, in seconds (built-in default: 3)."
+    },
+    "autoClean": {
+      "type": "boolean",
+      "description": "Run a `fleet clean` sweep after every successful `fleet merge` (built-in default: false)."
+    },
+    "copyOnSpawn": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      },
+      "description": "Repo-root-relative files/directories copied into every new worktree by `fleet spawn` — the gitignored essentials a fresh worktree lacks (.env, …). Entries must stay inside the repository."
+    },
+    "postSpawn": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Shell command run inside a new worktree after `fleet spawn` (e.g. \"npm ci\"). A failing hook is reported but the worktree is kept."
+    },
+    "preMerge": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Shell command run inside the agent's worktree before `fleet merge` starts (e.g. \"npm test\"). A non-zero exit aborts the merge."
+    }
+  }
+}