switchman-dev 0.1.6 → 0.1.7

package/src/core/enforcement.js

@@ -1,5 +1,5 @@
 import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
-import { dirname, join, resolve, relative } from 'path';
+import { dirname, join, posix, relative, resolve } from 'path';
 import { execFileSync, spawnSync } from 'child_process';
 
 import {
@@ -212,12 +212,15 @@ function classifyObservedPath(db, repoRoot, worktree, filePath, options = {}) {
 }
 
 function normalizeRepoPath(repoRoot, targetPath) {
-  const relativePath = String(targetPath || '').replace(/\\/g, '/').replace(/^\.\/+/, '');
+  const rawPath = String(targetPath || '').replace(/\\/g, '/').trim();
+  const relativePath = posix.normalize(rawPath.replace(/^\.\/+/, ''));
   if (
     relativePath === '' ||
-    relativePath.startsWith('..') ||
     relativePath === '.' ||
-    relativePath.startsWith('/')
+    relativePath === '..' ||
+    relativePath.startsWith('../') ||
+    rawPath.startsWith('/') ||
+    /^[A-Za-z]:\//.test(rawPath)
   ) {
     throw new Error('Target path must point to a file inside the repository.');
   }
@@ -529,7 +532,17 @@ export function gatewayMovePath(db, repoRoot, { leaseId, sourcePath, destination
 }
 
 export function gatewayMakeDirectory(db, repoRoot, { leaseId, path: targetPath, worktree = null }) {
-  const normalizedPath = String(targetPath || '').replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, '');
+  let normalizedPath;
+  try {
+    normalizedPath = normalizeRepoPath(repoRoot, targetPath).relativePath.replace(/\/+$/, '');
+  } catch {
+    return {
+      ok: false,
+      reason_code: 'policy_exception_required',
+      file_path: targetPath,
+      lease_id: leaseId,
+    };
+  }
   const lease = getLease(db, leaseId);
 
   if (!lease || lease.status !== 'active') {

package/src/core/git.js

@@ -4,8 +4,9 @@
  */
 
 import { execFileSync, execSync, spawnSync } from 'child_process';
-import { existsSync, realpathSync } from 'fs';
+import { existsSync, realpathSync, rmSync, statSync } from 'fs';
 import { join, relative, resolve, basename } from 'path';
+import { tmpdir } from 'os';
 import { filterIgnoredPaths } from './ignore.js';
 
 function normalizeFsPath(path) {
@@ -339,6 +340,289 @@ export function gitMergeBranchInto(repoRoot, baseBranch, topicBranch) {
   }
 }
 
+export function gitAssessBranchFreshness(repoRoot, baseBranch, topicBranch) {
+  const baseCommit = gitRevParse(repoRoot, baseBranch);
+  const topicCommit = gitRevParse(repoRoot, topicBranch);
+  if (!baseCommit || !topicCommit) {
+    return {
+      state: 'unknown',
+      base_commit: baseCommit || null,
+      topic_commit: topicCommit || null,
+      merge_base: null,
+    };
+  }
+
+  try {
+    const mergeBase = execFileSync('git', ['merge-base', baseBranch, topicBranch], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+    return {
+      state: mergeBase === baseCommit ? 'fresh' : 'behind',
+      base_commit: baseCommit,
+      topic_commit: topicCommit,
+      merge_base: mergeBase,
+    };
+  } catch {
+    return {
+      state: 'unknown',
+      base_commit: baseCommit,
+      topic_commit: topicCommit,
+      merge_base: null,
+    };
+  }
+}
+
+export function gitMaterializeIntegrationBranch(repoRoot, {
+  branch,
+  baseBranch = 'main',
+  mergeBranches = [],
+  tempWorktreePath = null,
+} = {}) {
+  const uniqueBranches = [...new Set(mergeBranches.filter(Boolean))].filter((candidate) => candidate !== branch);
+  const resolvedTempWorktreePath = tempWorktreePath || join(tmpdir(), `switchman-landing-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+
+  try {
+    execFileSync('git', ['worktree', 'add', '--detach', resolvedTempWorktreePath, baseBranch], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    execFileSync('git', ['checkout', '-B', branch, baseBranch], {
+      cwd: resolvedTempWorktreePath,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    for (const mergeBranch of uniqueBranches) {
+      execFileSync('git', ['merge', '--no-ff', '--no-edit', mergeBranch], {
+        cwd: resolvedTempWorktreePath,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    }
+
+    return {
+      branch,
+      base_branch: baseBranch,
+      merged_branches: uniqueBranches,
+      head_commit: gitRevParse(resolvedTempWorktreePath, 'HEAD'),
+      temp_worktree_path: resolvedTempWorktreePath,
+    };
+  } catch (err) {
+    const stderr = String(err?.stderr || '');
+    const stdout = String(err?.stdout || '');
+    const combinedOutput = `${stdout}${stderr}`.trim();
+    const message = String(err?.message || combinedOutput || 'Failed to materialize integration branch.');
+    const currentMergeBranch = uniqueBranches.find((candidate) =>
+      message.includes(candidate) || combinedOutput.includes(candidate),
+    ) || null;
+    let reasonCode = 'landing_branch_materialization_failed';
+    if (/CONFLICT|Automatic merge failed|Merge conflict/i.test(message) || /CONFLICT|Automatic merge failed/i.test(combinedOutput)) {
+      reasonCode = 'landing_branch_merge_conflict';
+    } else if (/not something we can merge|unknown revision|bad revision|not a valid object name/i.test(message) || /not something we can merge|unknown revision|bad revision|not a valid object name/i.test(combinedOutput)) {
+      reasonCode = 'landing_branch_missing_component';
+    } else if (message.includes(baseBranch) && /not something we can merge|unknown revision|bad revision|not a valid object name/i.test(message)) {
+      reasonCode = 'landing_branch_missing_base';
+    }
+    const conflictingFiles = reasonCode === 'landing_branch_merge_conflict'
+      ? execFileSync('git', ['diff', '--name-only', '--diff-filter=U'], {
+        cwd: resolvedTempWorktreePath,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      }).trim().split('\n').filter(Boolean)
+      : [];
+    try {
+      execFileSync('git', ['merge', '--abort'], {
+        cwd: resolvedTempWorktreePath,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch {
+      // No active merge to abort.
+    }
+    const landingError = new Error(message);
+    landingError.code = reasonCode;
+    landingError.details = {
+      branch,
+      base_branch: baseBranch,
+      merge_branches: uniqueBranches,
+      failed_branch: currentMergeBranch,
+      conflicting_files: conflictingFiles,
+      output: combinedOutput.slice(0, 1000),
+      temp_worktree_path: resolvedTempWorktreePath,
+    };
+    throw landingError;
+  } finally {
+    try {
+      execFileSync('git', ['worktree', 'remove', resolvedTempWorktreePath, '--force'], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch {
+      rmSync(resolvedTempWorktreePath, { recursive: true, force: true });
+    }
+  }
+}
+
+export function gitPrepareIntegrationRecoveryWorktree(repoRoot, {
+  branch,
+  baseBranch = 'main',
+  mergeBranches = [],
+  recoveryPath,
+} = {}) {
+  const uniqueBranches = [...new Set(mergeBranches.filter(Boolean))].filter((candidate) => candidate !== branch);
+  if (!recoveryPath) {
+    throw new Error('Recovery path is required.');
+  }
+  if (existsSync(recoveryPath)) {
+    throw new Error(`Recovery path already exists: ${recoveryPath}`);
+  }
+
+  execFileSync('git', ['worktree', 'add', '--detach', recoveryPath, baseBranch], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  try {
+    execFileSync('git', ['checkout', '-B', branch, baseBranch], {
+      cwd: recoveryPath,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    for (const mergeBranch of uniqueBranches) {
+      try {
+        execFileSync('git', ['merge', '--no-ff', '--no-edit', mergeBranch], {
+          cwd: recoveryPath,
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'pipe'],
+        });
+      } catch (err) {
+        const conflictingFiles = execFileSync('git', ['diff', '--name-only', '--diff-filter=U'], {
+          cwd: recoveryPath,
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim().split('\n').filter(Boolean);
+        return {
+          ok: false,
+          branch,
+          base_branch: baseBranch,
+          recovery_path: recoveryPath,
+          merged_branches: uniqueBranches,
+          failed_branch: mergeBranch,
+          conflicting_files: conflictingFiles,
+          output: `${String(err.stdout || '')}${String(err.stderr || '')}`.trim().slice(0, 1000),
+        };
+      }
+    }
+
+    return {
+      ok: true,
+      branch,
+      base_branch: baseBranch,
+      recovery_path: recoveryPath,
+      merged_branches: uniqueBranches,
+      head_commit: gitRevParse(recoveryPath, 'HEAD'),
+      conflicting_files: [],
+      failed_branch: null,
+      output: '',
+    };
+  } catch (err) {
+    try {
+      execFileSync('git', ['worktree', 'remove', recoveryPath, '--force'], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch {
+      rmSync(recoveryPath, { recursive: true, force: true });
+    }
+    throw err;
+  }
+}
+
+export function gitRemoveWorktree(repoRoot, worktreePath) {
+  execFileSync('git', ['worktree', 'remove', worktreePath, '--force'], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+export function gitPruneWorktrees(repoRoot) {
+  execFileSync('git', ['worktree', 'prune'], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+function isSwitchmanTempLandingWorktreePath(worktreePath) {
+  const resolvedPath = normalizeFsPath(worktreePath || '');
+  const tempRoot = normalizeFsPath(tmpdir());
+  return resolvedPath.startsWith(`${tempRoot}/`) && basename(resolvedPath).startsWith('switchman-landing-');
+}
+
+export function cleanupCrashedLandingTempWorktrees(
+  repoRoot,
+  {
+    olderThanMs = 15 * 60 * 1000,
+    now = Date.now(),
+  } = {},
+) {
+  const actions = [];
+  const beforePrune = listGitWorktrees(repoRoot)
+    .filter((worktree) => isSwitchmanTempLandingWorktreePath(worktree.path));
+  const missingBeforePrune = beforePrune.filter((worktree) => !existsSync(worktree.path));
+
+  gitPruneWorktrees(repoRoot);
+
+  const afterPrune = listGitWorktrees(repoRoot)
+    .filter((worktree) => isSwitchmanTempLandingWorktreePath(worktree.path));
+  const remainingPaths = new Set(afterPrune.map((worktree) => worktree.path));
+
+  for (const worktree of missingBeforePrune) {
+    if (!remainingPaths.has(worktree.path)) {
+      actions.push({
+        kind: 'stale_temp_worktree_pruned',
+        path: worktree.path,
+        branch: worktree.branch || null,
+      });
+    }
+  }
+
+  for (const worktree of afterPrune) {
+    if (!existsSync(worktree.path)) continue;
+
+    let ageMs = 0;
+    try {
+      ageMs = Math.max(0, now - statSync(worktree.path).mtimeMs);
+    } catch {
+      continue;
+    }
+
+    if (ageMs < olderThanMs) continue;
+
+    gitRemoveWorktree(repoRoot, worktree.path);
+    actions.push({
+      kind: 'stale_temp_worktree_removed',
+      path: worktree.path,
+      branch: worktree.branch || null,
+      age_ms: ageMs,
+    });
+  }
+
+  return {
+    repaired: actions.length > 0,
+    actions,
+  };
+}
+
 /**
  * Create a new git worktree
  */
@@ -348,6 +632,7 @@ export function createGitWorktree(repoRoot, name, branch) {
   execSync(`git worktree add -b "${branch}" "${wtPath}"`, {
     cwd: repoRoot,
     encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe'],
   });
   return wtPath;
 }

package/src/core/merge-gate.js

@@ -225,10 +225,24 @@ function evaluateDependencyInvalidations(db) {
   return listDependencyInvalidations(db, { status: 'stale' })
     .map((state) => {
       const affectedTask = getTask(db, state.affected_task_id);
-      const severity = affectedTask?.status === 'done' ? 'blocked' : 'warn';
+      const details = state.details || {};
+      const severity = details.severity || (affectedTask?.status === 'done' ? 'blocked' : 'warn');
       const staleArea = state.reason_type === 'subsystem_overlap'
         ? `subsystem:${state.subsystem_tag}`
+        : state.reason_type === 'semantic_contract_drift'
+          ? `contract:${(details.contract_names || []).join('|') || 'unknown'}`
+        : state.reason_type === 'semantic_object_overlap'
+          ? `object:${(details.object_names || []).join('|') || 'unknown'}`
+        : state.reason_type === 'shared_module_drift'
+          ? `module:${(details.module_paths || []).join('|') || 'unknown'}`
         : `${state.source_scope_pattern} ↔ ${state.affected_scope_pattern}`;
+      const summary = state.reason_type === 'semantic_contract_drift'
+        ? `${details.source_task_title || state.source_task_id} changed shared contract ${(details.contract_names || []).join(', ') || 'unknown'}`
+        : state.reason_type === 'semantic_object_overlap'
+          ? `${details.source_task_title || state.source_task_id} changed shared exported object ${(details.object_names || []).join(', ') || 'unknown'}`
+          : state.reason_type === 'shared_module_drift'
+            ? `${details.source_task_title || state.source_task_id} changed shared module ${(details.module_paths || []).join(', ') || 'unknown'} used by ${(details.dependent_files || []).join(', ') || state.affected_task_id}`
+          : `${affectedTask?.title || state.affected_task_id} is stale because ${details?.source_task_title || state.source_task_id} changed shared ${staleArea}`;
       return {
         source_lease_id: state.source_lease_id,
         source_task_id: state.source_task_id,
@@ -243,9 +257,10 @@ function evaluateDependencyInvalidations(db) {
         subsystem_tag: state.subsystem_tag,
         source_scope_pattern: state.source_scope_pattern,
         affected_scope_pattern: state.affected_scope_pattern,
-        summary: `${affectedTask?.title || state.affected_task_id} is stale because ${state.details?.source_task_title || state.source_task_id} changed shared ${staleArea}`,
+        summary,
         stale_area: staleArea,
         created_at: state.created_at,
+        details,
       };
     });
 }

package/src/core/outcome.js

@@ -183,7 +183,7 @@ export function evaluateTaskOutcome(db, repoRoot, { taskId = null, leaseId = nul
   };
 
   if (execution.leaseId) {
-    touchBoundaryValidationState(db, execution.leaseId, 'task_outcome_accepted');
+    touchBoundaryValidationState(db, execution.leaseId, 'task_outcome_accepted', { changed_files: changedFiles });
   }
 
   return result;