forge-workflow 0.0.9 → 0.0.10

package/scripts/benchmark.js

@@ -1,85 +1,371 @@
 #!/usr/bin/env node
 
-/**
- * Performance benchmark script for Forge CLI.
- * Measures CLI startup time, autoDetect, and detectFramework performance.
- *
- * Usage:
- *   node scripts/benchmark.js           # Human-readable output
- *   node scripts/benchmark.js --json    # JSON output (for CI/tests)
- */
-
-const { execFileSync } = require('node:child_process');
-const { performance } = require('node:perf_hooks');
-const path = require('node:path');
+const { spawnSync: defaultSpawnSync } = require('node:child_process');
 const fs = require('node:fs');
+const path = require('node:path');
+const { performance } = require('node:perf_hooks');
+
+const { buildProfile, parseJUnitFiles, walk } = require('./test-profile');
 
 const rootDir = path.join(__dirname, '..');
-const ITERATIONS = 3;
+const DEFAULT_OUTPUT = path.join(rootDir, 'test-results', 'benchmark-results.json');
+const DEFAULT_PROFILE_DIR = path.join(rootDir, 'test-results', 'benchmark-profiles');
+const DEFAULT_SAMPLES = 3;
+const DEFAULT_JUNIT_PATH = path.join(rootDir, 'test-results', 'test-results.xml');
 
-function benchmarkCLIStartup() {
-  const times = [];
-  for (let i = 0; i < ITERATIONS; i++) {
-    const start = performance.now();
-    execFileSync('node', [path.join(rootDir, 'bin', 'forge.js'), '--help'], {
-      cwd: rootDir,
-      encoding: 'utf-8',
-      timeout: 10000,
-      stdio: 'pipe'
-    });
-    times.push(performance.now() - start);
+const BENCHMARK_GROUPS = [
+  {
+    id: 'full-suite',
+    label: 'Whole suite',
+    command: ['bun', 'test'],
+  },
+  {
+    id: 'pre-push-runner',
+    label: 'Pre-push runner slice',
+    command: ['bun', 'test', 'test/scripts/test-runner.test.js'],
+  },
+  {
+    id: 'validation-core',
+    label: 'Validation core slice',
+    command: [
+      'bun',
+      'test',
+      'test/scripts/test-profile.test.js',
+      'test/scripts/test-ci-shard.test.js',
+      'test/scripts/test-runner.test.js',
+    ],
+  },
+  {
+    id: 'hotspot-shell',
+    label: 'Hotspot shell slice',
+    command: [
+      'bun',
+      'test',
+      'test/scripts/smart-status.conflicts.files.test.js',
+      'test/scripts/smart-status.conflicts.merge-tree.test.js',
+      'test/scripts/dep-guard.check-ripple.basic.test.js',
+    ],
+  },
+  {
+    id: 'validate',
+    label: 'Validate command',
+    command: ['bash', 'scripts/validate.sh'],
+  },
+];
+
+function parseArgs(argv) {
+  const args = {
+    groups: [],
+    json: false,
+    output: DEFAULT_OUTPUT,
+    profileDir: DEFAULT_PROFILE_DIR,
+    samples: DEFAULT_SAMPLES,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const current = argv[index];
+    const next = argv[index + 1];
+
+    if (current === '--json') args.json = true;
+    if (current === '--output') args.output = next;
+    if (current === '--profile-dir') args.profileDir = next;
+    if (current === '--samples') args.samples = Number.parseInt(next, 10) || DEFAULT_SAMPLES;
+    if (current === '--group') args.groups.push(next);
   }
-  const mean = times.reduce((a, b) => a + b, 0) / times.length;
-  return { name: 'CLI startup (--help)', mean: Math.round(mean), unit: 'ms', samples: ITERATIONS };
+
+  return args;
 }
 
-function benchmarkAutoDetect() {
-  const { autoDetect } = require(path.join(rootDir, 'lib', 'project-discovery.js'));
-  const times = [];
-  for (let i = 0; i < ITERATIONS; i++) {
-    const start = performance.now();
-    autoDetect(rootDir);
-    times.push(performance.now() - start);
+function resolveGroups(groupIds = []) {
+  if (groupIds.length === 0) {
+    return BENCHMARK_GROUPS.map((group) => ({ ...group, command: [...group.command] }));
+  }
+
+  const byId = new Map(BENCHMARK_GROUPS.map((group) => [group.id, group]));
+  const resolved = [];
+  for (const id of groupIds) {
+    const match = byId.get(id);
+    if (!match) {
+      throw new Error(`Unknown benchmark group: ${id}`);
+    }
+    resolved.push({ ...match, command: [...match.command] });
+  }
+  return resolved;
+}
+
+function roundMs(value) {
+  return Math.round(value);
+}
+
+function calculateMedian(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    return roundMs((sorted[middle - 1] + sorted[middle]) / 2);
+  }
+  return sorted[middle];
+}
+
+function summarizeSamples(samplesMs) {
+  if (samplesMs.length === 0) {
+    return {
+      maxMs: 0,
+      meanMs: 0,
+      medianMs: 0,
+      minMs: 0,
+      samplesMs: [],
+    };
+  }
+  const total = samplesMs.reduce((sum, value) => sum + value, 0);
+  return {
+    maxMs: Math.max(...samplesMs),
+    meanMs: roundMs(total / samplesMs.length),
+    medianMs: calculateMedian(samplesMs),
+    minMs: Math.min(...samplesMs),
+    samplesMs,
+  };
+}
+
+function buildJUnitCommand(command, junitPath) {
+  const [binary, subcommand, ...rest] = command;
+  if (binary === 'bun' && subcommand === 'test') {
+    return [
+      binary,
+      subcommand,
+      ...rest,
+      '--reporter=junit',
+      '--reporter-outfile',
+      junitPath,
+    ];
+  }
+  return [...command];
+}
+
+function runCommand(command, options = {}, spawnSync = defaultSpawnSync) {
+  const [binary, ...args] = command;
+  const result = spawnSync(binary, args, {
+    cwd: rootDir,
+    encoding: 'utf8',
+    stdio: 'pipe',
+    ...options,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if ((result.status ?? 1) !== 0) {
+    throw new Error(result.stderr || `Command failed: ${command.join(' ')}`);
+  }
+
+  return result;
+}
+
+function materializeJUnitFile(expectedPath) {
+  if (fs.existsSync(expectedPath)) {
+    return expectedPath;
   }
-  const mean = times.reduce((a, b) => a + b, 0) / times.length;
-  return { name: 'autoDetect()', mean: Math.round(mean), unit: 'ms', samples: ITERATIONS };
+
+  if (fs.existsSync(DEFAULT_JUNIT_PATH)) {
+    fs.mkdirSync(path.dirname(expectedPath), { recursive: true });
+    fs.copyFileSync(DEFAULT_JUNIT_PATH, expectedPath);
+    return expectedPath;
+  }
+
+  throw new Error(`Benchmark run did not produce JUnit output at ${expectedPath}`);
+}
+
+function removeMaterializedOutputs(expectedPath) {
+	const directory = path.dirname(expectedPath);
+	const extension = path.extname(expectedPath);
+	const basename = path.basename(expectedPath, extension);
+
+	if (!fs.existsSync(directory)) {
+		return;
+	}
+
+	for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+		if (!entry.isFile() || !entry.name.endsWith(extension)) {
+			continue;
+		}
+
+		if (entry.name === `${basename}${extension}` || entry.name.startsWith(`${basename}.`)) {
+			fs.rmSync(path.join(directory, entry.name), { force: true });
+		}
+	}
+}
+
+function indexXmlFiles(directory) {
+	return new Map(
+		walk(directory, '.xml').map((filePath) => {
+			const stats = fs.statSync(filePath);
+			return [filePath, `${stats.size}:${stats.mtimeMs}`];
+		}),
+	);
+}
+
+function listChangedXmlFiles(directory, beforeIndex) {
+	return walk(directory, '.xml')
+		.filter((filePath) => {
+			const stats = fs.statSync(filePath);
+			const fingerprint = `${stats.size}:${stats.mtimeMs}`;
+			return beforeIndex.get(filePath) !== fingerprint;
+		})
+		.sort((left, right) => left.localeCompare(right));
 }
 
-function benchmarkDetectFramework() {
-  const { detectFramework } = require(path.join(rootDir, 'lib', 'project-discovery.js'));
-  const times = [];
-  for (let i = 0; i < ITERATIONS; i++) {
+function materializeJUnitFiles(expectedPath, sourceFiles) {
+	const uniqueSources = [];
+	const seen = new Set();
+
+	for (const sourceFile of sourceFiles) {
+		if (typeof sourceFile !== 'string' || seen.has(sourceFile) || !fs.existsSync(sourceFile)) {
+			continue;
+		}
+		seen.add(sourceFile);
+		uniqueSources.push(sourceFile);
+	}
+
+	if (uniqueSources.length === 0) {
+		return [materializeJUnitFile(expectedPath)];
+	}
+
+	return uniqueSources.map((sourceFile, index) => {
+		const destination = index === 0
+			? expectedPath
+			: expectedPath.replace(/\.xml$/, `.${index + 1}.xml`);
+
+		if (sourceFile === destination) {
+			return destination;
+		}
+
+		fs.mkdirSync(path.dirname(destination), { recursive: true });
+		fs.copyFileSync(sourceFile, destination);
+		return destination;
+	});
+}
+
+function buildGroupProfile(group, xmlFiles) {
+  const metrics = parseJUnitFiles(xmlFiles);
+  return buildProfile({
+    integrationSkipped: true,
+    label: `benchmark-${group.id}`,
+  }, metrics);
+}
+
+function runBenchmarkGroup(group, options = {}) {
+  const profileDir = path.resolve(rootDir, options.profileDir || DEFAULT_PROFILE_DIR);
+  const samples = options.samples || DEFAULT_SAMPLES;
+  const spawnSync = options.spawnSync || defaultSpawnSync;
+
+  fs.mkdirSync(profileDir, { recursive: true });
+
+  const xmlFiles = [];
+  const samplesMs = [];
+
+  for (let sampleIndex = 0; sampleIndex < samples; sampleIndex += 1) {
+    const junitPath = path.join(profileDir, `${group.id}.sample-${sampleIndex + 1}.xml`);
+    removeMaterializedOutputs(junitPath);
+    fs.rmSync(DEFAULT_JUNIT_PATH, { force: true });
+    const beforeXmlFiles = indexXmlFiles(path.join(rootDir, 'test-results'));
+    const command = buildJUnitCommand(group.command, junitPath);
     const start = performance.now();
-    detectFramework(rootDir);
-    times.push(performance.now() - start);
+    runCommand(command, {}, spawnSync);
+    samplesMs.push(roundMs(performance.now() - start));
+    const changedXmlFiles = listChangedXmlFiles(path.join(rootDir, 'test-results'), beforeXmlFiles);
+    xmlFiles.push(...materializeJUnitFiles(junitPath, [
+      fs.existsSync(junitPath) ? junitPath : null,
+      ...changedXmlFiles,
+    ]));
   }
-  const mean = times.reduce((a, b) => a + b, 0) / times.length;
-  return { name: 'detectFramework()', mean: Math.round(mean), unit: 'ms', samples: ITERATIONS };
+
+  const summary = summarizeSamples(samplesMs);
+  const profile = buildGroupProfile(group, xmlFiles);
+  const profilePath = path.join(profileDir, `${group.id}.profile.json`);
+  fs.writeFileSync(profilePath, JSON.stringify(profile, null, 2));
+
+  return {
+    command: group.command.join(' '),
+    groupId: group.id,
+    groupLabel: group.label,
+    profilePath: path.relative(rootDir, profilePath).replace(/\\/g, '/'),
+    samples,
+    ...summary,
+  };
 }
 
-const results = [
-  benchmarkCLIStartup(),
-  benchmarkAutoDetect(),
-  benchmarkDetectFramework()
-];
+function buildBenchmarkResults(groups, results, timestamp = new Date().toISOString()) {
+  const totalMedianMs = results.reduce((sum, result) => sum + result.medianMs, 0);
+  const slowestGroup = [...results]
+    .sort((left, right) => right.medianMs - left.medianMs || left.groupId.localeCompare(right.groupId))[0] || null;
 
-const jsonMode = process.argv.includes('--json');
+  return {
+    groups: results,
+    requestedGroups: groups.map((group) => group.id),
+    samples: results[0]?.samples || DEFAULT_SAMPLES,
+    slowestGroup: slowestGroup
+      ? { groupId: slowestGroup.groupId, groupLabel: slowestGroup.groupLabel, medianMs: slowestGroup.medianMs }
+      : null,
+    timestamp,
+    totalMedianMs,
+  };
+}
+
+function formatResultLine(result) {
+  return `  ${result.groupLabel}: median ${result.medianMs}ms (min ${result.minMs}ms, max ${result.maxMs}ms)`;
+}
+
+function main(argv = process.argv.slice(2), deps = {}) {
+  const args = parseArgs(argv);
+  const groups = resolveGroups(args.groups);
+  const results = groups.map((group) => runBenchmarkGroup(group, {
+    profileDir: args.profileDir,
+    samples: args.samples,
+    spawnSync: deps.spawnSync,
+  }));
 
-if (jsonMode) {
-  process.stdout.write(JSON.stringify(results));
-} else {
-  console.log('\n  Forge Performance Benchmarks');
-  console.log('  ===========================\n');
-  for (const r of results) {
-    const status = r.mean < 1000 ? 'PASS' : r.mean < 3000 ? 'WARN' : 'SLOW';
-    console.log(`  ${status}  ${r.name}: ${r.mean}${r.unit} (${r.samples} samples)`);
+  const payload = buildBenchmarkResults(groups, results);
+  const outputPath = path.resolve(rootDir, args.output || DEFAULT_OUTPUT);
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+  fs.writeFileSync(outputPath, JSON.stringify(payload, null, 2));
+
+  if (args.json) {
+    process.stdout.write(JSON.stringify(payload));
+    return payload;
+  }
+
+  console.log('\n  Forge Test Benchmark Baselines');
+  console.log('  =============================\n');
+  for (const result of results) {
+    console.log(formatResultLine(result));
   }
-  console.log('');
+  console.log(`\n  Total median: ${payload.totalMedianMs}ms`);
+  console.log(`  Results saved to: ${path.relative(rootDir, outputPath).replace(/\\/g, '/')}\n`);
+  return payload;
+}
 
-  // Write results file
-  const outputPath = path.join(rootDir, 'benchmark-results.json');
-  fs.writeFileSync(outputPath, JSON.stringify(results, null, 2));
-  console.log(`  Results saved to: benchmark-results.json\n`);
+if (require.main === module) {
+  main();
 }
 
-module.exports = results;
+module.exports = {
+  BENCHMARK_GROUPS,
+  DEFAULT_OUTPUT,
+  DEFAULT_PROFILE_DIR,
+  DEFAULT_SAMPLES,
+  buildBenchmarkResults,
+  buildGroupProfile,
+  buildJUnitCommand,
+  calculateMedian,
+  formatResultLine,
+  main,
+  parseArgs,
+  resolveGroups,
+  roundMs,
+  materializeJUnitFile,
+  materializeJUnitFiles,
+  runBenchmarkGroup,
+  runCommand,
+  summarizeSamples,
+};

package/scripts/dep-guard-analyze.js

@@ -32,26 +32,61 @@ function normalizeSingleIssuePayload(payload) {
 	return {};
 }
 
+function readStdinPayload() {
+  const raw = fs.readFileSync(0, 'utf8');
+  if (!raw.trim()) {
+    throw new Error('Expected JSON payload on stdin');
+  }
+
+  const payload = JSON.parse(raw);
+  return {
+    currentIssue: normalizeSingleIssuePayload(payload.currentIssue),
+    openIssues: normalizeListPayload(payload.openIssues),
+    inProgressIssues: normalizeListPayload(payload.inProgressIssues),
+    taskFile: payload.taskFile,
+    repositoryRoot: payload.repositoryRoot || process.cwd(),
+  };
+}
+
 function main() {
-  const [
-    currentIssueFile,
-    openIssuesFile,
-    inProgressIssuesFile,
-    taskFile,
-    repositoryRoot = process.cwd(),
-  ] = process.argv.slice(2);
+  const args = process.argv.slice(2);
+  let currentIssue;
+  let openIssues;
+  let taskFile;
+  let repositoryRoot;
 
-  if (!currentIssueFile || !openIssuesFile || !inProgressIssuesFile || !taskFile) {
-    throw new Error(
-      'Usage: dep-guard-analyze.js <current-issue.json> <open-issues.json> <in-progress-issues.json> <task-file> [repository-root]',
-    );
-  }
+  if (args[0] === '--stdin') {
+    const payload = readStdinPayload();
+    currentIssue = payload.currentIssue;
+    openIssues = [
+      ...payload.openIssues,
+      ...payload.inProgressIssues,
+    ].filter((issue) => issue && issue.id && issue.id !== currentIssue.id);
+    taskFile = payload.taskFile;
+    repositoryRoot = payload.repositoryRoot;
+  } else {
+    const [
+      currentIssueFile,
+      openIssuesFile,
+      inProgressIssuesFile,
+      taskFileArg,
+      repositoryRootArg = process.cwd(),
+    ] = args;
 
-  const currentIssue = normalizeSingleIssuePayload(readJsonFile(currentIssueFile));
-  const openIssues = [
-    ...normalizeListPayload(readJsonFile(openIssuesFile)),
-    ...normalizeListPayload(readJsonFile(inProgressIssuesFile)),
-  ].filter((issue) => issue && issue.id && issue.id !== currentIssue.id);
+    if (!currentIssueFile || !openIssuesFile || !inProgressIssuesFile || !taskFileArg) {
+      throw new Error(
+        'Usage: dep-guard-analyze.js <current-issue.json> <open-issues.json> <in-progress-issues.json> <task-file> [repository-root]',
+      );
+    }
+
+    currentIssue = normalizeSingleIssuePayload(readJsonFile(currentIssueFile));
+    openIssues = [
+      ...normalizeListPayload(readJsonFile(openIssuesFile)),
+      ...normalizeListPayload(readJsonFile(inProgressIssuesFile)),
+    ].filter((issue) => issue && issue.id && issue.id !== currentIssue.id);
+    taskFile = taskFileArg;
+    repositoryRoot = repositoryRootArg;
+  }
 
   const result = analyzePhase3Dependencies({
     currentIssue,

package/scripts/dep-guard-keyword-ripple.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+'use strict';
+
+const {
+	parseActiveIssueLines,
+	renderKeywordRippleReport,
+} = require('../lib/dep-guard/keyword-ripple.js');
+
+function main() {
+	try {
+		const report = renderKeywordRippleReport({
+			issueId: process.env.ISSUE_ID || '',
+			sourceTitle: process.env.SOURCE_TITLE || '',
+			activeIssues: parseActiveIssueLines(process.env.LIST_OUTPUT || ''),
+		});
+
+		if (report.overlapCount > 0) {
+			process.stdout.write(`⚠️  ${report.output}\n`);
+			return;
+		}
+
+		process.stdout.write(`✅ ${report.output}\n`);
+	} catch (error) {
+		console.error(`dep-guard-keyword-ripple: ${error.message}`);
+		process.exit(1);
+	}
+}
+
+main();

package/scripts/dep-guard-render-review.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+
+function readAnalysis() {
+  const raw = fs.readFileSync(0, 'utf8');
+  if (!raw.trim()) {
+    throw new Error('Expected JSON analysis payload on stdin');
+  }
+  return JSON.parse(raw);
+}
+
+function renderPhase3Review(analysis) {
+  const detectorCategories = Object.entries(analysis.scores ?? {})
+    .filter(([name, score]) => name !== 'rubric' && Number(score) > 0)
+    .map(([name]) => name);
+
+  const lines = [
+    '',
+    `Structured dependency review for ${analysis.currentIssue.id}...`,
+    '',
+  ];
+
+  if (!Array.isArray(analysis.issues) || analysis.issues.length === 0) {
+    lines.push('No conflicts detected');
+    return `${lines.join('\n')}\n`;
+  }
+
+  const seenPairs = new Set();
+  for (const finding of analysis.issues) {
+    const key = `${analysis.currentIssue.id}->${finding.targetIssueId}`;
+    if (seenPairs.has(key)) {
+      continue;
+    }
+    seenPairs.add(key);
+    lines.push(`Issue pair: ${analysis.currentIssue.id} -> ${finding.targetIssueId}`);
+  }
+
+  lines.push(`Rubric score: ${analysis.scores?.rubric ?? 0}`);
+  lines.push(
+    `Confidence: ${(analysis.confidence?.score ?? 0).toFixed(2)}${
+      analysis.confidence?.belowThreshold ? ' (below 70% threshold)' : ''
+    }`,
+  );
+  lines.push(`Detector categories: ${detectorCategories.join(', ') || 'none'}`);
+  lines.push(`Needs user decision: ${analysis.needsUserDecision ? 'yes' : 'no'}`);
+
+  if (Array.isArray(analysis.detectorConflicts) && analysis.detectorConflicts.length > 0) {
+    lines.push('Conflicts:');
+    for (const conflict of analysis.detectorConflicts) {
+      lines.push(`  - ${conflict}`);
+    }
+  }
+
+  if (Array.isArray(analysis.proposals) && analysis.proposals.length > 0) {
+    lines.push('');
+    lines.push('Proposed dependency updates:');
+    for (const proposal of analysis.proposals) {
+      lines.push(`  - ${proposal.dependentIssueId} depends on ${proposal.dependsOnIssueId}`);
+      if (Array.isArray(proposal.pros) && proposal.pros.length > 0) {
+        lines.push(`    Pros: ${proposal.pros.join('; ')}`);
+      }
+      if (Array.isArray(proposal.cons) && proposal.cons.length > 0) {
+        lines.push(`    Cons: ${proposal.cons.join('; ')}`);
+      }
+    }
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+function main() {
+  process.stdout.write(renderPhase3Review(readAnalysis()));
+}
+
+try {
+  main();
+} catch (error) {
+  process.stderr.write(`${error.message}\n`);
+  process.exit(1);
+}
+
+module.exports = {
+  renderPhase3Review,
+};