switchman-dev 0.1.2 → 0.1.4

package/src/core/detector.js

@@ -3,12 +3,15 @@
  * Scans all registered worktrees for file-level and branch-level conflicts
  */
 
-import { listWorktrees } from './db.js';
+import { listScopeReservations, listWorktrees } from './db.js';
 import {
   listGitWorktrees,
   getWorktreeChangedFiles,
   checkMergeConflicts,
 } from './git.js';
+import { filterIgnoredPaths } from './ignore.js';
+import { evaluateRepoCompliance } from './enforcement.js';
+import { buildSemanticIndexForPath, detectSemanticConflicts } from './semantic.js';
 
 /**
  * Scan all worktrees for conflicts.
@@ -20,12 +23,22 @@ export async function scanAllWorktrees(db, repoRoot) {
 
   // Build a unified list, merging db metadata with git reality
   const worktrees = mergeWorktreeInfo(dbWorktrees, gitWorktrees);
+  const enforcement = evaluateRepoCompliance(db, repoRoot, worktrees);
 
   if (worktrees.length < 2) {
     return {
       worktrees,
+      fileMap: {},
       conflicts: [],
       fileConflicts: [],
+      ownershipConflicts: detectOwnershipOverlaps(db),
+      semanticConflicts: [],
+      unclaimedChanges: enforcement.unclaimedChanges,
+      worktreeCompliance: enforcement.worktreeCompliance,
+      complianceSummary: enforcement.complianceSummary,
+      deniedWrites: enforcement.deniedWrites,
+      commitGateFailures: enforcement.commitGateFailures,
+      scannedAt: new Date().toISOString(),
       summary: 'Less than 2 worktrees. Nothing to compare.',
     };
   }
@@ -40,6 +53,13 @@ export async function scanAllWorktrees(db, repoRoot) {
 
   // Step 2: Detect file-level overlaps (fast, always available)
   const fileConflicts = detectFileOverlaps(fileMap, worktrees);
+  const ownershipConflicts = detectOwnershipOverlaps(db);
+  const semanticIndexes = worktrees.map((wt) => ({
+    worktree: wt.name,
+    branch: wt.branch || 'unknown',
+    objects: buildSemanticIndexForPath(wt.path, fileMap[wt.name] || []).objects,
+  }));
+  const semanticConflicts = detectSemanticConflicts(semanticIndexes);
 
   // Step 3: Detect branch-level merge conflicts (slower, uses git merge-tree)
   const branchConflicts = [];
@@ -48,27 +68,34 @@ export async function scanAllWorktrees(db, repoRoot) {
   for (const [wtA, wtB] of pairs) {
     if (!wtA.branch || !wtB.branch) continue;
     const result = checkMergeConflicts(repoRoot, wtA.branch, wtB.branch);
-    if (result.hasConflicts) {
+    const conflictingFiles = filterIgnoredPaths(result.conflictingFiles || []);
+    if (result.hasConflicts && conflictingFiles.length > 0) {
       branchConflicts.push({
         type: result.isOverlapOnly ? 'file_overlap' : 'merge_conflict',
         worktreeA: wtA.name,
         worktreeB: wtB.name,
         branchA: wtA.branch,
         branchB: wtB.branch,
-        conflictingFiles: result.conflictingFiles,
+        conflictingFiles,
         details: result.details,
       });
     }
   }
 
   const allConflicts = [...branchConflicts];
-
   return {
     worktrees,
     fileMap,
     conflicts: allConflicts,
     fileConflicts,
-    summary: buildSummary(worktrees, allConflicts, fileConflicts),
+    ownershipConflicts,
+    semanticConflicts,
+    unclaimedChanges: enforcement.unclaimedChanges,
+    worktreeCompliance: enforcement.worktreeCompliance,
+    complianceSummary: enforcement.complianceSummary,
+    deniedWrites: enforcement.deniedWrites,
+    commitGateFailures: enforcement.commitGateFailures,
+    summary: buildSummary(worktrees, allConflicts, fileConflicts, ownershipConflicts, semanticConflicts, enforcement.unclaimedChanges),
     scannedAt: new Date().toISOString(),
   };
 }
@@ -96,6 +123,70 @@ function detectFileOverlaps(fileMap, worktrees) {
   return conflicts;
 }
 
+function normalizeScopeRoot(pattern) {
+  return String(pattern || '')
+    .replace(/\\/g, '/')
+    .replace(/\/\*\*$/, '')
+    .replace(/\/\*$/, '')
+    .replace(/\/+$/, '');
+}
+
+function scopeRootsOverlap(leftPattern, rightPattern) {
+  const left = normalizeScopeRoot(leftPattern);
+  const right = normalizeScopeRoot(rightPattern);
+  if (!left || !right) return false;
+  return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+}
+
+function detectOwnershipOverlaps(db) {
+  const reservations = listScopeReservations(db);
+  const conflicts = [];
+
+  for (let i = 0; i < reservations.length; i++) {
+    for (let j = i + 1; j < reservations.length; j++) {
+      const left = reservations[i];
+      const right = reservations[j];
+      if (left.lease_id === right.lease_id) continue;
+      if (left.worktree === right.worktree) continue;
+
+      if (
+        left.ownership_level === 'subsystem' &&
+        right.ownership_level === 'subsystem' &&
+        left.subsystem_tag &&
+        left.subsystem_tag === right.subsystem_tag
+      ) {
+        conflicts.push({
+          type: 'subsystem_overlap',
+          worktreeA: left.worktree,
+          worktreeB: right.worktree,
+          leaseA: left.lease_id,
+          leaseB: right.lease_id,
+          subsystemTag: left.subsystem_tag,
+        });
+        continue;
+      }
+
+      if (
+        left.ownership_level === 'path_scope' &&
+        right.ownership_level === 'path_scope' &&
+        scopeRootsOverlap(left.scope_pattern, right.scope_pattern)
+      ) {
+        conflicts.push({
+          type: 'scope_overlap',
+          worktreeA: left.worktree,
+          worktreeB: right.worktree,
+          leaseA: left.lease_id,
+          leaseB: right.lease_id,
+          scopeA: left.scope_pattern,
+          scopeB: right.scope_pattern,
+        });
+      }
+    }
+  }
+
+  return conflicts;
+}
+
 /**
  * Check if claiming a set of files from a worktree would conflict with current activity
  */
@@ -135,6 +226,8 @@ function mergeWorktreeInfo(dbWorktrees, gitWorktrees) {
     const dbMatch = dbWorktrees.find(d => d.path === gw.path || d.name === gw.name);
     return {
       ...gw,
+      name: dbMatch?.name || gw.name,
+      branch: dbMatch?.branch || gw.branch,
       agent: dbMatch?.agent || null,
       registeredInDb: !!dbMatch,
     };
@@ -153,11 +246,11 @@ function getPairs(arr) {
   return pairs;
 }
 
-function buildSummary(worktrees, conflicts, fileConflicts) {
+function buildSummary(worktrees, conflicts, fileConflicts, ownershipConflicts, semanticConflicts, unclaimedChanges) {
   const lines = [];
   lines.push(`Scanned ${worktrees.length} worktree(s)`);
 
-  if (conflicts.length === 0 && fileConflicts.length === 0) {
+  if (conflicts.length === 0 && fileConflicts.length === 0 && ownershipConflicts.length === 0 && semanticConflicts.length === 0) {
     lines.push('✓ No conflicts detected');
   } else {
     if (conflicts.length > 0) {
@@ -166,6 +259,15 @@ function buildSummary(worktrees, conflicts, fileConflicts) {
     if (fileConflicts.length > 0) {
       lines.push(`⚠ ${fileConflicts.length} file(s) being edited in multiple worktrees`);
     }
+    if (ownershipConflicts.length > 0) {
+      lines.push(`⚠ ${ownershipConflicts.length} ownership boundary overlap(s) detected`);
+    }
+    if (semanticConflicts.length > 0) {
+      lines.push(`⚠ ${semanticConflicts.length} semantic overlap(s) detected`);
+    }
+    if (unclaimedChanges.length > 0) {
+      lines.push(`⚠ ${unclaimedChanges.length} worktree(s) have unclaimed changed files`);
+    }
   }
 
   return lines.join('\n');