switchman-dev 0.1.2 → 0.1.4

package/src/core/queue.js

@@ -0,0 +1,225 @@
+import { getMergeQueueItem, listMergeQueue, listTasks, listWorktrees, markMergeQueueState, startMergeQueueItem } from './db.js';
+import { gitBranchExists, gitMergeBranchInto, gitRebaseOnto } from './git.js';
+import { runAiMergeGate } from './merge-gate.js';
+import { scanAllWorktrees } from './detector.js';
+
+function describeQueueError(err) {
+  const message = String(err?.stderr || err?.message || err || '').trim();
+  if (/conflict/i.test(message)) {
+    return {
+      code: 'merge_conflict',
+      summary: message || 'Merge conflict blocked queue item.',
+      nextAction: 'Resolve the branch conflict manually, then run `switchman queue retry <itemId>`.',
+      retryable: true,
+    };
+  }
+
+  if (/not a valid object name|pathspec|did not match any file/i.test(message)) {
+    return {
+      code: 'source_missing',
+      summary: message || 'The queued source branch no longer exists.',
+      nextAction: 'Recreate the source branch or remove the queue item.',
+      retryable: false,
+    };
+  }
+
+  return {
+    code: 'merge_failed',
+    summary: message || 'Merge queue item failed.',
+    nextAction: 'Inspect the branch state, then retry or remove the queue item.',
+    retryable: true,
+  };
+}
+
+function scheduleRetryOrBlock(db, item, failure) {
+  const retriesUsed = Number(item.retry_count || 0);
+  const maxRetries = Number(item.max_retries || 0);
+  if (failure.retryable && retriesUsed < maxRetries) {
+    return {
+      status: 'retrying',
+      item: markMergeQueueState(db, item.id, {
+        status: 'retrying',
+        lastErrorCode: failure.code,
+        lastErrorSummary: failure.summary,
+        nextAction: `Retry ${retriesUsed + 1} of ${maxRetries} scheduled automatically. Run \`switchman queue run\` again after fixing any underlying branch drift if needed.`,
+        incrementRetry: true,
+      }),
+    };
+  }
+
+  return {
+    status: 'blocked',
+    item: markMergeQueueState(db, item.id, {
+      status: 'blocked',
+      lastErrorCode: failure.code,
+      lastErrorSummary: failure.summary,
+      nextAction: failure.nextAction.replace('<itemId>', item.id),
+    }),
+  };
+}
+
+async function evaluateQueueRepoGate(db, repoRoot) {
+  const report = await scanAllWorktrees(db, repoRoot);
+  const aiGate = await runAiMergeGate(db, repoRoot);
+  const ok = report.conflicts.length === 0
+    && report.fileConflicts.length === 0
+    && (report.ownershipConflicts?.length || 0) === 0
+    && (report.semanticConflicts?.length || 0) === 0
+    && report.unclaimedChanges.length === 0
+    && report.complianceSummary.non_compliant === 0
+    && report.complianceSummary.stale === 0
+    && aiGate.status !== 'blocked'
+    && (aiGate.dependency_invalidations?.filter((item) => item.severity === 'blocked').length || 0) === 0;
+
+  return {
+    ok,
+    summary: ok
+      ? `Repo gate passed for ${report.worktrees.length} worktree(s).`
+      : 'Repo gate rejected unmanaged changes, stale leases, ownership conflicts, stale dependency invalidations, or boundary validation failures.',
+    report,
+    aiGate,
+  };
+}
+
+export function resolveQueueSource(db, repoRoot, item) {
+  if (!item) {
+    throw new Error('Queue item is required.');
+  }
+
+  if (item.source_type === 'branch') {
+    return {
+      branch: item.source_ref,
+      worktree: item.source_worktree || null,
+      pipeline_id: item.source_pipeline_id || null,
+    };
+  }
+
+  if (item.source_type === 'worktree') {
+    const worktree = listWorktrees(db).find((entry) => entry.name === item.source_worktree || entry.name === item.source_ref);
+    if (!worktree) {
+      throw new Error(`Queued worktree ${item.source_worktree || item.source_ref} is not registered.`);
+    }
+    return {
+      branch: worktree.branch,
+      worktree: worktree.name,
+      worktree_path: worktree.path,
+      pipeline_id: item.source_pipeline_id || null,
+    };
+  }
+
+  if (item.source_type === 'pipeline') {
+    const tasks = listTasks(db).filter((task) => task.id.startsWith(`${item.source_pipeline_id || item.source_ref}-`));
+    const implementationTask = tasks.find((task) => task.worktree);
+    if (!implementationTask?.worktree) {
+      throw new Error(`Pipeline ${item.source_pipeline_id || item.source_ref} has no landed worktree branch to queue.`);
+    }
+    const worktree = listWorktrees(db).find((entry) => entry.name === implementationTask.worktree);
+    if (!worktree) {
+      throw new Error(`Queued pipeline worktree ${implementationTask.worktree} is not registered.`);
+    }
+    return {
+      branch: worktree.branch,
+      worktree: worktree.name,
+      worktree_path: worktree.path,
+      pipeline_id: item.source_pipeline_id || item.source_ref,
+    };
+  }
+
+  throw new Error(`Unsupported queue source type: ${item.source_type}`);
+}
+
+export function inferQueueNextAction(item) {
+  if (!item) return null;
+  if (item.status === 'blocked' && item.next_action) return item.next_action;
+  if (item.status === 'merged') return 'No action needed.';
+  return null;
+}
+
+export function buildQueueStatusSummary(items) {
+  const counts = {
+    queued: items.filter((item) => item.status === 'queued').length,
+    validating: items.filter((item) => item.status === 'validating').length,
+    rebasing: items.filter((item) => item.status === 'rebasing').length,
+    merging: items.filter((item) => item.status === 'merging').length,
+    retrying: items.filter((item) => item.status === 'retrying').length,
+    blocked: items.filter((item) => item.status === 'blocked').length,
+    merged: items.filter((item) => item.status === 'merged').length,
+  };
+
+  return {
+    counts,
+    next: items.find((item) => ['queued', 'retrying', 'validating', 'rebasing', 'merging'].includes(item.status)) || null,
+    blocked: items.filter((item) => item.status === 'blocked'),
+  };
+}
+
+export async function runNextQueueItem(db, repoRoot, { targetBranch = 'main' } = {}) {
+  const nextItem = listMergeQueue(db).find((item) => ['queued', 'retrying'].includes(item.status));
+  if (!nextItem) {
+    return { status: 'idle', item: null };
+  }
+
+  const started = startMergeQueueItem(db, nextItem.id);
+  if (!started) {
+    return { status: 'idle', item: null };
+  }
+
+  try {
+    const resolved = resolveQueueSource(db, repoRoot, started);
+    const queueTarget = started.target_branch || targetBranch;
+
+    if (!gitBranchExists(repoRoot, resolved.branch)) {
+      return scheduleRetryOrBlock(db, started, {
+        code: 'source_missing',
+        summary: `Source branch ${resolved.branch} does not exist.`,
+        nextAction: `Remove this queue item or recreate ${resolved.branch}, then run \`switchman queue retry ${started.id}\`.`,
+        retryable: false,
+      });
+    }
+
+    markMergeQueueState(db, started.id, { status: 'rebasing' });
+    gitRebaseOnto(resolved.worktree_path || repoRoot, queueTarget, resolved.branch);
+
+    const gate = await evaluateQueueRepoGate(db, repoRoot);
+    if (!gate.ok) {
+      return {
+        status: 'blocked',
+        item: markMergeQueueState(db, started.id, {
+          status: 'blocked',
+          lastErrorCode: 'gate_failed',
+          lastErrorSummary: gate.summary,
+          nextAction: `Run \`switchman gate ci\`, resolve the reported issues, then run \`switchman queue retry ${started.id}\`.`,
+        }),
+      };
+    }
+
+    markMergeQueueState(db, started.id, { status: 'merging' });
+    const mergedCommit = gitMergeBranchInto(repoRoot, queueTarget, resolved.branch);
+
+    return {
+      status: 'merged',
+      item: markMergeQueueState(db, started.id, {
+        status: 'merged',
+        mergedCommit,
+      }),
+    };
+  } catch (err) {
+    const failure = describeQueueError(err);
+    return scheduleRetryOrBlock(db, started, failure);
+  }
+}
+
+export async function runMergeQueue(db, repoRoot, { maxItems = 1, targetBranch = 'main' } = {}) {
+  const processed = [];
+  for (let count = 0; count < maxItems; count++) {
+    const result = await runNextQueueItem(db, repoRoot, { targetBranch });
+    if (!result.item) break;
+    processed.push(result);
+    if (result.status !== 'merged') break;
+  }
+
+  return {
+    processed,
+    summary: buildQueueStatusSummary(listMergeQueue(db)),
+  };
+}

package/src/core/semantic.js

@@ -0,0 +1,311 @@
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+const SOURCE_EXTENSIONS = new Set(['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx']);
+
+const SUBSYSTEM_PATTERNS = [
+  { key: 'auth', regex: /(^|\/)(auth|login|session|permissions?|rbac|acl)(\/|$)/i },
+  { key: 'schema', regex: /(^|\/)(schema|migrations?|db|database|sql)(\/|$)|schema\./i },
+  { key: 'config', regex: /(^|\/)(config|configs|settings)(\/|$)|(^|\/)(package\.json|pnpm-lock\.yaml|package-lock\.json|yarn\.lock|tsconfig.*|vite\.config.*|webpack\.config.*)$/i },
+  { key: 'api', regex: /(^|\/)(api|routes?|controllers?)(\/|$)/i },
+  { key: 'payments', regex: /(^|\/)(payments?|billing|invoice|checkout|subscription)(\/|$)/i },
+  { key: 'ui', regex: /(^|\/)(components?|ui|pages?)(\/|$)/i },
+];
+
+function uniq(values) {
+  return [...new Set(values)];
+}
+
+function isSourceLikePath(filePath) {
+  return [...SOURCE_EXTENSIONS].some((ext) => filePath.endsWith(ext));
+}
+
+function classifySubsystems(filePath) {
+  const tags = SUBSYSTEM_PATTERNS.filter((pattern) => pattern.regex.test(filePath)).map((pattern) => pattern.key);
+  return tags.length > 0 ? tags : ['general'];
+}
+
+function areaForPath(filePath) {
+  const parts = String(filePath || '').split('/').filter(Boolean);
+  if (parts.length === 0) return 'repo';
+  if (parts.length === 1) return parts[0];
+  if (['src', 'app', 'lib', 'server', 'client', 'tests', 'test', 'spec', 'specs'].includes(parts[0])) {
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return parts[0];
+}
+
+function extractExports(content) {
+  const objects = [];
+  const patterns = [
+    { kind: 'function', regex: /export\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/g },
+    { kind: 'class', regex: /export\s+class\s+([A-Za-z_$][\w$]*)/g },
+    { kind: 'const', regex: /export\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)/g },
+    { kind: 'type', regex: /export\s+type\s+([A-Za-z_$][\w$]*)/g },
+    { kind: 'interface', regex: /export\s+interface\s+([A-Za-z_$][\w$]*)/g },
+    { kind: 'enum', regex: /export\s+enum\s+([A-Za-z_$][\w$]*)/g },
+  ];
+
+  for (const pattern of patterns) {
+    for (const match of content.matchAll(pattern.regex)) {
+      objects.push({ kind: pattern.kind, name: match[1] });
+    }
+  }
+
+  if (/export\s+default\s+/.test(content)) {
+    objects.push({ kind: 'default', name: 'default' });
+  }
+
+  return uniq(objects.map((item) => `${item.kind}:${item.name}`)).map((key) => {
+    const [kind, name] = key.split(':');
+    return { kind, name };
+  });
+}
+
+function extractExportBlocks(content) {
+  const lines = String(content || '').split('\n');
+  const blocks = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim().startsWith('export ')) continue;
+
+    const blockLines = [line];
+    let braceDepth = (line.match(/{/g) || []).length - (line.match(/}/g) || []).length;
+    let needsTerminator = !/[;}]$/.test(line.trim());
+
+    while (i + 1 < lines.length && (braceDepth > 0 || needsTerminator)) {
+      i += 1;
+      const nextLine = lines[i];
+      blockLines.push(nextLine);
+      braceDepth += (nextLine.match(/{/g) || []).length - (nextLine.match(/}/g) || []).length;
+      if (braceDepth <= 0 && /[;}]$/.test(nextLine.trim())) {
+        needsTerminator = false;
+      }
+    }
+
+    blocks.push(blockLines.join('\n').trim());
+  }
+
+  return blocks.filter(Boolean);
+}
+
+function parseFileObjects(repoPath, filePath) {
+  const absolutePath = join(repoPath, filePath);
+  if (!existsSync(absolutePath) || !isSourceLikePath(filePath)) return [];
+
+  const content = readFileSync(absolutePath, 'utf8');
+  const exports = extractExports(content);
+  const exportBlocks = extractExportBlocks(content);
+  const subsystemTags = classifySubsystems(filePath);
+  const area = areaForPath(filePath);
+
+  return exports.map((entry, index) => ({
+    object_id: `${filePath}#${entry.kind}:${entry.name}`,
+    file_path: filePath,
+    kind: entry.kind,
+    name: entry.name,
+    area,
+    subsystem_tags: subsystemTags,
+    source_text: exportBlocks[index] || `export ${entry.kind} ${entry.name}`,
+  }));
+}
+
+function trackedFiles(repoPath) {
+  try {
+    const output = execSync('git ls-files', {
+      cwd: repoPath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    return output.split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+export function buildSemanticIndexForPath(repoPath, filePaths = null) {
+  const files = filePaths || trackedFiles(repoPath);
+  const objects = files
+    .filter(isSourceLikePath)
+    .flatMap((filePath) => parseFileObjects(repoPath, filePath))
+    .sort((left, right) =>
+      left.file_path.localeCompare(right.file_path)
+      || left.kind.localeCompare(right.kind)
+      || left.name.localeCompare(right.name)
+    );
+
+  return {
+    generated_at: new Date().toISOString(),
+    object_count: objects.length,
+    objects: objects.map(({ source_text, ...object }) => object),
+  };
+}
+
+export function detectSemanticConflicts(semanticIndexes = []) {
+  const conflicts = [];
+
+  for (let i = 0; i < semanticIndexes.length; i++) {
+    for (let j = i + 1; j < semanticIndexes.length; j++) {
+      const left = semanticIndexes[i];
+      const right = semanticIndexes[j];
+      const rightByName = new Map();
+      for (const object of right.objects) {
+        if (!rightByName.has(object.name)) rightByName.set(object.name, []);
+        rightByName.get(object.name).push(object);
+      }
+
+      for (const leftObject of left.objects) {
+        const matching = rightByName.get(leftObject.name) || [];
+        for (const rightObject of matching) {
+          if (leftObject.object_id === rightObject.object_id) {
+            conflicts.push({
+              type: 'semantic_object_overlap',
+              severity: 'blocked',
+              worktreeA: left.worktree,
+              worktreeB: right.worktree,
+              object_name: leftObject.name,
+              object_kind: leftObject.kind,
+              fileA: leftObject.file_path,
+              fileB: rightObject.file_path,
+              area: leftObject.area,
+            });
+            continue;
+          }
+
+          const sharedSubsystems = leftObject.subsystem_tags.filter((tag) => rightObject.subsystem_tags.includes(tag));
+          if (sharedSubsystems.length > 0 || leftObject.area === rightObject.area) {
+            conflicts.push({
+              type: 'semantic_name_overlap',
+              severity: 'warn',
+              worktreeA: left.worktree,
+              worktreeB: right.worktree,
+              object_name: leftObject.name,
+              object_kind_a: leftObject.kind,
+              object_kind_b: rightObject.kind,
+              fileA: leftObject.file_path,
+              fileB: rightObject.file_path,
+              shared_subsystems: sharedSubsystems,
+              area: leftObject.area === rightObject.area ? leftObject.area : null,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return uniq(conflicts.map((item) => JSON.stringify(item))).map((item) => JSON.parse(item));
+}
+
+export function materializeSemanticIndex(repoRoot, { worktrees = [] } = {}) {
+  const semanticIndex = {
+    generated_at: new Date().toISOString(),
+    worktrees: worktrees
+      .map((worktree) => ({
+        worktree: worktree.name,
+        branch: worktree.branch || 'unknown',
+        index: buildSemanticIndexForPath(worktree.path),
+      }))
+      .sort((left, right) => left.worktree.localeCompare(right.worktree)),
+  };
+
+  const switchmanDir = join(repoRoot, '.switchman');
+  if (!existsSync(switchmanDir)) mkdirSync(switchmanDir, { recursive: true });
+  const outputPath = join(switchmanDir, 'semantic-index.json');
+  writeFileSync(outputPath, `${JSON.stringify(semanticIndex, null, 2)}\n`);
+  return {
+    output_path: outputPath,
+    semantic_index: semanticIndex,
+  };
+}
+
+function normalizeObjectRow(row) {
+  return {
+    ...row,
+    subsystem_tags: JSON.parse(row.subsystem_tags || '[]'),
+  };
+}
+
+export function importCodeObjectsToStore(db, repoRoot, { filePaths = null } = {}) {
+  const files = filePaths || trackedFiles(repoRoot);
+  const objects = files
+    .filter(isSourceLikePath)
+    .flatMap((filePath) => parseFileObjects(repoRoot, filePath));
+
+  const upsert = db.prepare(`
+    INSERT INTO code_objects (object_id, file_path, kind, name, source_text, subsystem_tags, area, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
+    ON CONFLICT(object_id) DO UPDATE SET
+      file_path=excluded.file_path,
+      kind=excluded.kind,
+      name=excluded.name,
+      source_text=excluded.source_text,
+      subsystem_tags=excluded.subsystem_tags,
+      area=excluded.area,
+      updated_at=datetime('now')
+  `);
+
+  for (const object of objects) {
+    upsert.run(
+      object.object_id,
+      object.file_path,
+      object.kind,
+      object.name,
+      object.source_text,
+      JSON.stringify(object.subsystem_tags || []),
+      object.area || null,
+    );
+  }
+
+  return listCodeObjects(db);
+}
+
+export function listCodeObjects(db, { filePath = null } = {}) {
+  const where = filePath ? 'WHERE file_path=?' : '';
+  const params = filePath ? [filePath] : [];
+  return db.prepare(`
+    SELECT *
+    FROM code_objects
+    ${where}
+    ORDER BY file_path ASC, kind ASC, name ASC
+  `).all(...params).map(normalizeObjectRow);
+}
+
+export function updateCodeObjectSource(db, objectId, sourceText) {
+  db.prepare(`
+    UPDATE code_objects
+    SET source_text=?,
+        updated_at=datetime('now')
+    WHERE object_id=?
+  `).run(sourceText, objectId);
+  const row = db.prepare(`SELECT * FROM code_objects WHERE object_id=?`).get(objectId);
+  return row ? normalizeObjectRow(row) : null;
+}
+
+export function materializeCodeObjects(db, repoRoot, { outputRoot = repoRoot } = {}) {
+  const objects = listCodeObjects(db);
+  const byFile = new Map();
+  for (const object of objects) {
+    if (!byFile.has(object.file_path)) byFile.set(object.file_path, []);
+    byFile.get(object.file_path).push(object);
+  }
+
+  const files = [];
+  for (const [filePath, entries] of byFile.entries()) {
+    const absolutePath = join(outputRoot, filePath);
+    const dirPath = absolutePath.split('/').slice(0, -1).join('/');
+    if (!existsSync(dirPath)) mkdirSync(dirPath, { recursive: true });
+    const ordered = entries
+      .slice()
+      .sort((left, right) => left.kind.localeCompare(right.kind) || left.name.localeCompare(right.name));
+    const content = `${ordered.map((entry) => entry.source_text.trim()).join('\n\n')}\n`;
+    writeFileSync(absolutePath, content);
+    files.push(filePath);
+  }
+
+  return {
+    output_root: outputRoot,
+    file_count: files.length,
+    files: files.sort(),
+  };
+}