switchman-dev 0.1.0

package/src/core/db.js

@@ -0,0 +1,240 @@
+/**
+ * switchman - Database layer
+ * SQLite-backed task queue and file ownership registry
+ */
+
+import { DatabaseSync } from 'node:sqlite';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join, resolve } from 'path';
+
+const SWITCHMAN_DIR = '.switchman';
+const DB_FILE = 'switchman.db';
+
+// How long (ms) a writer will wait for a lock before giving up.
+// 5 seconds is generous for a CLI tool with 3-10 concurrent agents.
+const BUSY_TIMEOUT_MS = 5000;
+
+export function getSwitchmanDir(repoRoot) {
+  return join(repoRoot, SWITCHMAN_DIR);
+}
+
+export function getDbPath(repoRoot) {
+  return join(repoRoot, SWITCHMAN_DIR, DB_FILE);
+}
+
+export function initDb(repoRoot) {
+  const dir = getSwitchmanDir(repoRoot);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  const db = new DatabaseSync(getDbPath(repoRoot));
+
+  db.exec(`
+    PRAGMA journal_mode=WAL;
+    PRAGMA synchronous=NORMAL;
+    PRAGMA busy_timeout=${BUSY_TIMEOUT_MS};
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id          TEXT PRIMARY KEY,
+      title       TEXT NOT NULL,
+      description TEXT,
+      status      TEXT NOT NULL DEFAULT 'pending',
+      worktree    TEXT,
+      agent       TEXT,
+      priority    INTEGER DEFAULT 5,
+      created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at  TEXT NOT NULL DEFAULT (datetime('now')),
+      completed_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS file_claims (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id     TEXT NOT NULL,
+      file_path   TEXT NOT NULL,
+      worktree    TEXT NOT NULL,
+      agent       TEXT,
+      claimed_at  TEXT NOT NULL DEFAULT (datetime('now')),
+      released_at TEXT,
+      FOREIGN KEY(task_id) REFERENCES tasks(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS worktrees (
+      name        TEXT PRIMARY KEY,
+      path        TEXT NOT NULL,
+      branch      TEXT NOT NULL,
+      agent       TEXT,
+      status      TEXT NOT NULL DEFAULT 'idle',
+      registered_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_seen   TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS conflict_log (
+      id            INTEGER PRIMARY KEY AUTOINCREMENT,
+      detected_at   TEXT NOT NULL DEFAULT (datetime('now')),
+      worktree_a    TEXT NOT NULL,
+      worktree_b    TEXT NOT NULL,
+      conflicting_files TEXT NOT NULL,
+      resolved      INTEGER DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_file_claims_path ON file_claims(file_path);
+    CREATE INDEX IF NOT EXISTS idx_file_claims_active ON file_claims(released_at) WHERE released_at IS NULL;
+  `);
+
+  return db;
+}
+
+export function openDb(repoRoot) {
+  const dbPath = getDbPath(repoRoot);
+  if (!existsSync(dbPath)) {
+    throw new Error(`No switchman database found. Run 'switchman init' first.`);
+  }
+  const db = new DatabaseSync(dbPath);
+  db.exec(`PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA busy_timeout=${BUSY_TIMEOUT_MS};`);
+  return db;
+}
+
+// ─── Tasks ────────────────────────────────────────────────────────────────────
+
+export function createTask(db, { id, title, description, priority = 5 }) {
+  const taskId = id || `task-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+  db.prepare(`
+    INSERT INTO tasks (id, title, description, priority)
+    VALUES (?, ?, ?, ?)
+  `).run(taskId, title, description || null, priority);
+  return taskId;
+}
+
+export function assignTask(db, taskId, worktree, agent) {
+  const result = db.prepare(`
+    UPDATE tasks
+    SET status='in_progress', worktree=?, agent=?, updated_at=datetime('now')
+    WHERE id=? AND status='pending'
+  `).run(worktree, agent || null, taskId);
+  return result.changes > 0;
+}
+
+export function completeTask(db, taskId) {
+  db.prepare(`
+    UPDATE tasks
+    SET status='done', completed_at=datetime('now'), updated_at=datetime('now')
+    WHERE id=?
+  `).run(taskId);
+}
+
+export function failTask(db, taskId, reason) {
+  db.prepare(`
+    UPDATE tasks
+    SET status='failed', description=COALESCE(description,'') || '\nFAILED: ' || ?, updated_at=datetime('now')
+    WHERE id=?
+  `).run(reason || 'unknown', taskId);
+}
+
+export function listTasks(db, statusFilter) {
+  if (statusFilter) {
+    return db.prepare(`SELECT * FROM tasks WHERE status=? ORDER BY priority DESC, created_at ASC`).all(statusFilter);
+  }
+  return db.prepare(`SELECT * FROM tasks ORDER BY priority DESC, created_at ASC`).all();
+}
+
+export function getTask(db, taskId) {
+  return db.prepare(`SELECT * FROM tasks WHERE id=?`).get(taskId);
+}
+
+export function getNextPendingTask(db) {
+  return db.prepare(`
+    SELECT * FROM tasks WHERE status='pending'
+    ORDER BY priority DESC, created_at ASC LIMIT 1
+  `).get();
+}
+
+// ─── File Claims ──────────────────────────────────────────────────────────────
+
+export function claimFiles(db, taskId, worktree, filePaths, agent) {
+  const insert = db.prepare(`
+    INSERT INTO file_claims (task_id, file_path, worktree, agent)
+    VALUES (?, ?, ?, ?)
+  `);
+  // node:sqlite's DatabaseSync doesn't have .transaction() like better-sqlite3.
+  // We use explicit BEGIN/COMMIT/ROLLBACK. The key correctness fix vs. the old
+  // code: we only ROLLBACK if we're actually inside a transaction (i.e. after
+  // BEGIN succeeded), and we re-throw so callers can handle failures.
+  db.exec('BEGIN');
+  try {
+    for (const fp of filePaths) {
+      insert.run(taskId, fp, worktree, agent || null);
+    }
+    db.exec('COMMIT');
+  } catch (err) {
+    try { db.exec('ROLLBACK'); } catch { /* already rolled back */ }
+    throw err;
+  }
+}
+
+export function releaseFileClaims(db, taskId) {
+  db.prepare(`
+    UPDATE file_claims SET released_at=datetime('now')
+    WHERE task_id=? AND released_at IS NULL
+  `).run(taskId);
+}
+
+export function getActiveFileClaims(db) {
+  return db.prepare(`
+    SELECT fc.*, t.title as task_title, t.status as task_status
+    FROM file_claims fc
+    JOIN tasks t ON fc.task_id = t.id
+    WHERE fc.released_at IS NULL
+    ORDER BY fc.file_path
+  `).all();
+}
+
+export function checkFileConflicts(db, filePaths, excludeWorktree) {
+  const conflicts = [];
+  const stmt = db.prepare(`
+    SELECT fc.*, t.title as task_title
+    FROM file_claims fc
+    JOIN tasks t ON fc.task_id = t.id
+    WHERE fc.file_path=?
+      AND fc.released_at IS NULL
+      AND fc.worktree != ?
+      AND t.status NOT IN ('done','failed')
+  `);
+  for (const fp of filePaths) {
+    const existing = stmt.get(fp, excludeWorktree || '');
+    if (existing) conflicts.push({ file: fp, claimedBy: existing });
+  }
+  return conflicts;
+}
+
+// ─── Worktrees ────────────────────────────────────────────────────────────────
+
+export function registerWorktree(db, { name, path, branch, agent }) {
+  db.prepare(`
+    INSERT INTO worktrees (name, path, branch, agent)
+    VALUES (?, ?, ?, ?)
+    ON CONFLICT(name) DO UPDATE SET
+      path=excluded.path, branch=excluded.branch,
+      agent=excluded.agent, last_seen=datetime('now'), status='idle'
+  `).run(name, path, branch, agent || null);
+}
+
+export function listWorktrees(db) {
+  return db.prepare(`SELECT * FROM worktrees ORDER BY registered_at`).all();
+}
+
+export function updateWorktreeStatus(db, name, status) {
+  db.prepare(`UPDATE worktrees SET status=?, last_seen=datetime('now') WHERE name=?`).run(status, name);
+}
+
+// ─── Conflict Log ─────────────────────────────────────────────────────────────
+
+export function logConflict(db, worktreeA, worktreeB, conflictingFiles) {
+  db.prepare(`
+    INSERT INTO conflict_log (worktree_a, worktree_b, conflicting_files)
+    VALUES (?, ?, ?)
+  `).run(worktreeA, worktreeB, JSON.stringify(conflictingFiles));
+}
+
+export function getConflictLog(db) {
+  return db.prepare(`SELECT * FROM conflict_log ORDER BY detected_at DESC LIMIT 50`).all();
+}

package/src/core/detector.js

@@ -0,0 +1,172 @@
+/**
+ * switchman - Conflict Detector
+ * Scans all registered worktrees for file-level and branch-level conflicts
+ */
+
+import { listWorktrees } from './db.js';
+import {
+  listGitWorktrees,
+  getWorktreeChangedFiles,
+  checkMergeConflicts,
+} from './git.js';
+
+/**
+ * Scan all worktrees for conflicts.
+ * Returns a full conflict report.
+ */
+export async function scanAllWorktrees(db, repoRoot) {
+  const dbWorktrees = listWorktrees(db);
+  const gitWorktrees = listGitWorktrees(repoRoot);
+
+  // Build a unified list, merging db metadata with git reality
+  const worktrees = mergeWorktreeInfo(dbWorktrees, gitWorktrees);
+
+  if (worktrees.length < 2) {
+    return {
+      worktrees,
+      conflicts: [],
+      fileConflicts: [],
+      summary: 'Less than 2 worktrees. Nothing to compare.',
+    };
+  }
+
+  // Step 1: Get changed files per worktree
+  const fileMap = {}; // worktree name -> [files]
+  for (const wt of worktrees) {
+    if (wt.path) {
+      fileMap[wt.name] = getWorktreeChangedFiles(wt.path, repoRoot);
+    }
+  }
+
+  // Step 2: Detect file-level overlaps (fast, always available)
+  const fileConflicts = detectFileOverlaps(fileMap, worktrees);
+
+  // Step 3: Detect branch-level merge conflicts (slower, uses git merge-tree)
+  const branchConflicts = [];
+  const pairs = getPairs(worktrees.filter(w => w.branch && !w.isMain));
+
+  for (const [wtA, wtB] of pairs) {
+    if (!wtA.branch || !wtB.branch) continue;
+    const result = checkMergeConflicts(repoRoot, wtA.branch, wtB.branch);
+    if (result.hasConflicts) {
+      branchConflicts.push({
+        type: result.isOverlapOnly ? 'file_overlap' : 'merge_conflict',
+        worktreeA: wtA.name,
+        worktreeB: wtB.name,
+        branchA: wtA.branch,
+        branchB: wtB.branch,
+        conflictingFiles: result.conflictingFiles,
+        details: result.details,
+      });
+    }
+  }
+
+  const allConflicts = [...branchConflicts];
+
+  return {
+    worktrees,
+    fileMap,
+    conflicts: allConflicts,
+    fileConflicts,
+    summary: buildSummary(worktrees, allConflicts, fileConflicts),
+    scannedAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Detect which worktrees are touching the same files right now (uncommitted)
+ */
+function detectFileOverlaps(fileMap, worktrees) {
+  const fileToWorktrees = {}; // file -> [worktree names]
+
+  for (const [wtName, files] of Object.entries(fileMap)) {
+    for (const file of files) {
+      if (!fileToWorktrees[file]) fileToWorktrees[file] = [];
+      fileToWorktrees[file].push(wtName);
+    }
+  }
+
+  const conflicts = [];
+  for (const [file, wts] of Object.entries(fileToWorktrees)) {
+    if (wts.length > 1) {
+      conflicts.push({ file, worktrees: wts });
+    }
+  }
+
+  return conflicts;
+}
+
+/**
+ * Check if claiming a set of files from a worktree would conflict with current activity
+ */
+export function preflightCheck(db, repoRoot, proposedFiles, worktreeName) {
+  const gitWorktrees = listGitWorktrees(repoRoot);
+  const fileMap = {};
+
+  for (const wt of gitWorktrees) {
+    if (wt.name !== worktreeName) {
+      fileMap[wt.name] = getWorktreeChangedFiles(wt.path, repoRoot);
+    }
+  }
+
+  const conflicts = [];
+  for (const file of proposedFiles) {
+    for (const [wtName, files] of Object.entries(fileMap)) {
+      if (files.includes(file)) {
+        conflicts.push({ file, conflictsWith: wtName });
+      }
+    }
+  }
+
+  return {
+    safe: conflicts.length === 0,
+    conflicts,
+  };
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function mergeWorktreeInfo(dbWorktrees, gitWorktrees) {
+  const gitMap = {};
+  for (const wt of gitWorktrees) gitMap[wt.path] = wt;
+
+  // Start with git worktrees as the source of truth
+  const result = gitWorktrees.map(gw => {
+    const dbMatch = dbWorktrees.find(d => d.path === gw.path || d.name === gw.name);
+    return {
+      ...gw,
+      agent: dbMatch?.agent || null,
+      registeredInDb: !!dbMatch,
+    };
+  });
+
+  return result;
+}
+
+function getPairs(arr) {
+  const pairs = [];
+  for (let i = 0; i < arr.length; i++) {
+    for (let j = i + 1; j < arr.length; j++) {
+      pairs.push([arr[i], arr[j]]);
+    }
+  }
+  return pairs;
+}
+
+function buildSummary(worktrees, conflicts, fileConflicts) {
+  const lines = [];
+  lines.push(`Scanned ${worktrees.length} worktree(s)`);
+
+  if (conflicts.length === 0 && fileConflicts.length === 0) {
+    lines.push('✓ No conflicts detected');
+  } else {
+    if (conflicts.length > 0) {
+      lines.push(`⚠ ${conflicts.length} branch conflict(s) detected`);
+    }
+    if (fileConflicts.length > 0) {
+      lines.push(`⚠ ${fileConflicts.length} file(s) being edited in multiple worktrees`);
+    }
+  }
+
+  return lines.join('\n');
+}

package/src/core/git.js

@@ -0,0 +1,265 @@
+/**
+ * switchman - Git utilities
+ * Worktree discovery and conflict detection via git merge-tree
+ */
+
+import { execSync, spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join, relative, resolve, basename } from 'path';
+
+/**
+ * Find the switchman database root from cwd or a given path.
+ *
+ * Problem: `git rev-parse --show-toplevel` returns the *current worktree's*
+ * root when called from inside a linked worktree — not the main repo where
+ * .switchman/ lives. We handle this in two steps:
+ *
+ *   1. Use `git rev-parse --show-toplevel` to get the current worktree root.
+ *   2. Use `git rev-parse --git-common-dir` to find the shared .git directory,
+ *      then resolve the main repo root from there.
+ *
+ * This means `switchman scan` works correctly whether you run it from:
+ *   /projects/myapp/              (main worktree)
+ *   /projects/myapp-feature-auth/ (linked worktree)
+ */
+export function findRepoRoot(startPath = process.cwd()) {
+  try {
+    // Step 1: confirm we're inside *some* git repo
+    execSync('git rev-parse --show-toplevel', {
+      cwd: startPath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    // Step 2: get the shared git dir (e.g. /projects/myapp/.git or
+    // /projects/myapp/.git/worktrees/feature-auth). For the main worktree
+    // this resolves to the .git dir itself; for linked worktrees it points
+    // to .git/worktrees/<name> inside the main repo.
+    const commonDir = execSync('git rev-parse --git-common-dir', {
+      cwd: startPath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    // --git-common-dir returns a path relative to cwd (or absolute).
+    // We need the directory that *contains* the .git folder.
+    const resolvedCommon = resolve(startPath, commonDir);
+
+    // resolvedCommon is something like /projects/myapp/.git
+    // The main repo root is its parent.
+    const mainRoot = resolve(resolvedCommon, '..');
+
+    return mainRoot;
+  } catch {
+    throw new Error('Not inside a git repository. Run switchman from inside a git repo.');
+  }
+}
+
+/**
+ * List all git worktrees for this repo
+ * Returns: [{ name, path, branch, isMain, HEAD }]
+ */
+export function listGitWorktrees(repoRoot) {
+  try {
+    const output = execSync('git worktree list --porcelain', {
+      cwd: repoRoot,
+      encoding: 'utf8',
+    });
+
+    const worktrees = [];
+    const blocks = output.trim().split('\n\n');
+
+    for (const block of blocks) {
+      if (!block.trim()) continue;
+      const lines = block.trim().split('\n');
+      const wt = {};
+
+      for (const line of lines) {
+        if (line.startsWith('worktree ')) wt.path = line.slice(9).trim();
+        else if (line.startsWith('HEAD ')) wt.HEAD = line.slice(5).trim();
+        else if (line.startsWith('branch ')) wt.branch = line.slice(7).trim().replace('refs/heads/', '');
+        else if (line === 'bare') wt.bare = true;
+        else if (line === 'detached') wt.detached = true;
+      }
+
+      if (wt.path) {
+        wt.name = wt.path === repoRoot ? 'main' : wt.path.split('/').pop();
+        wt.isMain = wt.path === repoRoot;
+        worktrees.push(wt);
+      }
+    }
+
+    return worktrees;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get files changed in a worktree relative to its base branch
+ * Returns array of file paths (relative to repo root)
+ */
+export function getWorktreeChangedFiles(worktreePath, repoRoot) {
+  try {
+    // Get both staged and unstaged changes
+    const staged = execSync('git diff --name-only --cached', {
+      cwd: worktreePath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const unstaged = execSync('git diff --name-only', {
+      cwd: worktreePath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const allFiles = [
+      ...staged.split('\n'),
+      ...unstaged.split('\n'),
+    ].filter(Boolean);
+
+    return [...new Set(allFiles)];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check for merge conflicts between two branches using git merge-tree
+ * Returns: { hasConflicts: bool, conflictingFiles: string[], details: string }
+ */
+export function checkMergeConflicts(repoRoot, branchA, branchB) {
+  try {
+    // Find merge base
+    const mergeBase = execSync(`git merge-base ${branchA} ${branchB}`, {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    // Run merge-tree (read-only simulation)
+    const result = spawnSync(
+      'git',
+      ['merge-tree', '--write-tree', '--name-only', mergeBase, branchA, branchB],
+      {
+        cwd: repoRoot,
+        encoding: 'utf8',
+      }
+    );
+
+    const output = (result.stdout || '') + (result.stderr || '');
+if (result.status === 0 || !output.includes('CONFLICT')) {
+  return { hasConflicts: false, conflictingFiles: [], details: '' };
+}
+const conflictingFiles = parseConflictingFiles(output);
+
+    return {
+      hasConflicts: true,
+      conflictingFiles,
+      details: output.slice(0, 500),
+    };
+  } catch (err) {
+    // Fallback: compare changed file sets for overlap
+    return checkFileOverlap(repoRoot, branchA, branchB);
+  }
+}
+
+/**
+ * Fallback: check if two branches touch the same files
+ */
+function checkFileOverlap(repoRoot, branchA, branchB) {
+  try {
+    const mergeBase = execSync(`git merge-base ${branchA} ${branchB}`, {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const filesA = execSync(`git diff --name-only ${mergeBase} ${branchA}`, {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim().split('\n').filter(Boolean);
+
+    const filesB = execSync(`git diff --name-only ${mergeBase} ${branchB}`, {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim().split('\n').filter(Boolean);
+
+    const setB = new Set(filesB);
+    const overlap = filesA.filter(f => setB.has(f));
+
+    return {
+      hasConflicts: overlap.length > 0,
+      conflictingFiles: overlap,
+      details: overlap.length ? `File overlap detected (not necessarily merge conflict)` : '',
+      isOverlapOnly: true,
+    };
+  } catch {
+    return { hasConflicts: false, conflictingFiles: [], details: 'Could not compare branches', error: true };
+  }
+}
+
+function parseConflictingFiles(output) {
+  const files = new Set();
+  const lines = output.split('\n');
+  for (const line of lines) {
+    // "CONFLICT (content): Merge conflict in path/to/file.js"
+    // This is the only reliable format across git versions.
+    const match = line.trim().match(/Merge conflict in (.+)$/);
+    if (match) files.add(match[1].trim());
+  }
+  return [...files];
+}
+
+/**
+ * Get the current branch of a worktree
+ */
+export function getWorktreeBranch(worktreePath) {
+  try {
+    return execSync('git branch --show-current', {
+      cwd: worktreePath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Create a new git worktree
+ */
+export function createGitWorktree(repoRoot, name, branch) {
+  const repoName = basename(repoRoot);
+  const wtPath = join(repoRoot, '..', `${repoName}-${name}`);
+  execSync(`git worktree add -b "${branch}" "${wtPath}"`, {
+    cwd: repoRoot,
+    encoding: 'utf8',
+  });
+  return wtPath;
+}
+
+/**
+ * Get summary stats for a worktree
+ */
+export function getWorktreeStats(worktreePath) {
+  try {
+    const status = execSync('git status --short', {
+      cwd: worktreePath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const lines = status.split('\n').filter(Boolean);
+    const modified = lines.filter(l => l.startsWith(' M') || l.startsWith('M ')).length;
+    const added = lines.filter(l => l.startsWith('A ') || l.startsWith('??')).length;
+    const deleted = lines.filter(l => l.startsWith(' D') || l.startsWith('D ')).length;
+
+    return { modified, added, deleted, total: lines.length, raw: status };
+  } catch {
+    return { modified: 0, added: 0, deleted: 0, total: 0, raw: '' };
+  }
+}