crewswarm 0.9.1 → 0.9.3

package/scripts/smoke-dispatch.mjs

@@ -108,7 +108,10 @@ async function run() {
 
   const chatMarker = `SMOKE_CHAT_OK_${runId}`;
   console.log("[1/4] chat...");
-  const chatResult = await chat(`say: ${chatMarker}`, `smoke-chat-${runId}`);
+  const chatResult = await chat(
+    `Reply with exactly: ${chatMarker}`,
+    `smoke-chat-${runId}`,
+  );
   const chatReply = String(chatResult?.reply || chatResult?.message || "");
   assert(chatReply.includes(chatMarker), `chat reply missing marker (${chatMarker})`);
   console.log("[ok] /chat");

package/scripts/test-blast-radius.mjs

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { execSync } from "node:child_process";
+
+function safeExec(command) {
+  try {
+    return execSync(command, {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5000,
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function normalizeRelative(filePath) {
+  return path.relative(process.cwd(), filePath).replace(/\\/g, "/");
+}
+
+function fingerprintFile(filePath) {
+  const stat = fs.statSync(filePath);
+  const content = fs.readFileSync(filePath);
+  return {
+    path: filePath,
+    relative_file: normalizeRelative(filePath),
+    size_bytes: stat.size,
+    mtime: stat.mtime.toISOString(),
+    sha256: crypto.createHash("sha256").update(content).digest("hex"),
+  };
+}
+
+function tryResolve(baseDir, specifier) {
+  const raw = path.resolve(baseDir, specifier);
+  const candidates = [
+    raw,
+    `${raw}.mjs`,
+    `${raw}.js`,
+    `${raw}.json`,
+    path.join(raw, "index.mjs"),
+    path.join(raw, "index.js"),
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function collectImports(filePath) {
+  const text = fs.readFileSync(filePath, "utf8");
+  const patterns = [
+    /(?:import|export)\s+[^'"]*?from\s+['"]([^'"]+)['"]/g,
+    /import\(\s*['"]([^'"]+)['"]\s*\)/g,
+  ];
+  const imports = new Set();
+  for (const pattern of patterns) {
+    for (const match of text.matchAll(pattern)) {
+      const specifier = match[1];
+      if (!specifier || !specifier.startsWith(".")) continue;
+      const resolved = tryResolve(path.dirname(filePath), specifier);
+      if (resolved && resolved.startsWith(process.cwd())) imports.add(resolved);
+    }
+  }
+  return [...imports];
+}
+
+export function buildDependencySnapshot(filePath, maxDepth = 3) {
+  if (!filePath || !fs.existsSync(filePath)) return { files: [] };
+  const visited = new Set();
+  const queue = [{ filePath, depth: 0 }];
+  while (queue.length) {
+    const current = queue.shift();
+    if (!current?.filePath || visited.has(current.filePath)) continue;
+    visited.add(current.filePath);
+    if (current.depth >= maxDepth) continue;
+    for (const imported of collectImports(current.filePath)) {
+      queue.push({ filePath: imported, depth: current.depth + 1 });
+    }
+  }
+  return {
+    max_depth: maxDepth,
+    files: [...visited]
+      .sort()
+      .map((item) => {
+        try {
+          return fingerprintFile(item);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean),
+  };
+}
+
+export function getWorkspaceState() {
+  const tracked = safeExec("git diff --name-only HEAD --");
+  const untracked = safeExec("git ls-files --others --exclude-standard");
+  const changedFiles = [
+    ...(tracked ? tracked.split("\n").filter(Boolean) : []),
+    ...(untracked ? untracked.split("\n").filter(Boolean) : []),
+  ].map((item) => item.replace(/\\/g, "/"));
+  return {
+    git_commit: safeExec("git rev-parse HEAD"),
+    git_branch: safeExec("git branch --show-current"),
+    changed_files: [...new Set(changedFiles)].sort(),
+    dirty: changedFiles.length > 0,
+  };
+}
+
+export function assessTestFreshness(test, workspaceState = getWorkspaceState(), baselineWorkspaceState = test.workspace_state_at_run_start || null) {
+  const snapshotFiles = test.dependency_snapshot?.files || [];
+  if (snapshotFiles.length === 0) {
+    return {
+      status: "unknown",
+      rerun_advice: workspaceState.dirty ? "rerun_recommended" : "rerun_not_needed",
+      reason: "no dependency snapshot available",
+      changed_relevant_files: [],
+      dependency_changes: [],
+    };
+  }
+
+  const changedSet = new Set(workspaceState.changed_files || []);
+  const baselineChangedSet = new Set(baselineWorkspaceState?.changed_files || []);
+  const newlyChangedSet = new Set(
+    [...changedSet].filter((file) => !baselineChangedSet.has(file))
+  );
+  const changedRelevant = snapshotFiles
+    .map((file) => file.relative_file)
+    .filter((relativeFile) => newlyChangedSet.has(relativeFile));
+
+  const dependencyChanges = [];
+  for (const dependency of snapshotFiles) {
+    const absolutePath = dependency.path || path.join(process.cwd(), dependency.relative_file);
+    try {
+      const current = fingerprintFile(absolutePath);
+      if (current.sha256 !== dependency.sha256) {
+        dependencyChanges.push({
+          file: dependency.relative_file,
+          previous_sha256: dependency.sha256,
+          current_sha256: current.sha256,
+        });
+      }
+    } catch {
+      dependencyChanges.push({
+        file: dependency.relative_file,
+        previous_sha256: dependency.sha256,
+        current_sha256: null,
+        missing: true,
+      });
+    }
+  }
+
+  if (changedRelevant.length || dependencyChanges.length) {
+    return {
+      status: "stale",
+      rerun_advice: "rerun_required",
+      reason: changedRelevant.length
+        ? "tracked workspace changes intersect this test's dependency graph"
+        : "dependency fingerprints changed since this test last ran",
+      changed_relevant_files: changedRelevant,
+      dependency_changes: dependencyChanges,
+    };
+  }
+
+  if (!workspaceState.dirty) {
+    return {
+      status: "fresh",
+      rerun_advice: "rerun_not_needed",
+      reason: "workspace has no uncommitted changes",
+      changed_relevant_files: [],
+      dependency_changes: [],
+    };
+  }
+
+  return {
+    status: "fresh",
+    rerun_advice: "rerun_not_needed",
+    reason: baselineWorkspaceState
+      ? "workspace changed, but not since this test run in this test's dependency graph"
+      : "workspace changed, but not in this test's dependency graph",
+    changed_relevant_files: [],
+    dependency_changes: [],
+  };
+}
+
+export function summarizeFreshness(tests, workspaceState = getWorkspaceState()) {
+  const assessments = tests.map((test) => ({
+    test,
+    freshness: assessTestFreshness(test, workspaceState),
+  }));
+  return {
+    workspace: workspaceState,
+    stale: assessments.filter((item) => item.freshness.status === "stale").length,
+    fresh: assessments.filter((item) => item.freshness.status === "fresh").length,
+    unknown: assessments.filter((item) => item.freshness.status === "unknown").length,
+    assessments,
+  };
+}

package/scripts/test-report-summary.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { getWorkspaceState, summarizeFreshness, assessTestFreshness } from "./test-blast-radius.mjs";
+
+const resultsDir = process.env.TEST_RESULTS_DIR || path.join(process.cwd(), "test-results");
+const summaryPath = path.join(resultsDir, ".last-run.json");
+
+if (!fs.existsSync(summaryPath)) {
+  console.error(`No summary found at ${summaryPath}`);
+  process.exit(1);
+}
+
+const summary = JSON.parse(fs.readFileSync(summaryPath, "utf8"));
+const runDir = path.join(resultsDir, "runs", summary.runId);
+const markdownPath = path.join(runDir, "summary.md");
+const workspaceState = getWorkspaceState();
+const baselineWorkspaceState = summary.workspace_state_at_run_start || null;
+const freshnessSummary = summarizeFreshness(
+  (summary.tests || []).map((test) => ({ ...test, workspace_state_at_run_start: baselineWorkspaceState })),
+  workspaceState
+);
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function rerunCommand(test) {
+  return test.rerun_command || `node --test --test-reporter=./scripts/test-reporter.mjs --test-name-pattern=${shellQuote(test.name)} ${shellQuote(test.file)}`;
+}
+
+console.log(`Run: ${summary.runId}`);
+console.log(`Status: ${summary.status}`);
+console.log(`Passed: ${summary.passed}  Failed: ${summary.failed}  Skipped: ${summary.skipped}`);
+console.log(`Duration: ${(summary.duration_ms / 1000).toFixed(2)}s`);
+console.log(`Artifacts: ${runDir}`);
+console.log(`Workspace: ${workspaceState.dirty ? `${workspaceState.changed_files.length} changed file(s)` : "clean"}`);
+console.log(`Blast radius: ${freshnessSummary.stale} stale  ${freshnessSummary.fresh} fresh  ${freshnessSummary.unknown} unknown`);
+
+if (!workspaceState.dirty) {
+  console.log("Rerun guidance: no workspace changes detected, so prior results are still valid unless the environment changed.");
+} else if (freshnessSummary.stale === 0) {
+  console.log("Rerun guidance: workspace changed, but no recorded test dependency graph was hit.");
+} else {
+  console.log("Rerun guidance: rerun the stale tests rather than the full suite first.");
+}
+
+if (summary.failedTests?.length) {
+  console.log("\nFailed tests:");
+  for (const failure of summary.failedTests) {
+    const freshness = assessTestFreshness(failure, workspaceState, baselineWorkspaceState);
+    console.log(`- ${failure.name}`);
+    console.log(`  file: ${failure.file}`);
+    console.log(`  reason: ${failure.reason_code} (${failure.reason_summary})`);
+    console.log(`  error: ${failure.error || "unknown"}`);
+    console.log(`  freshness: ${freshness.status} (${freshness.rerun_advice})`);
+    if (freshness.changed_relevant_files?.length) {
+      console.log(`  blast radius: ${freshness.changed_relevant_files.join(", ")}`);
+    }
+    if (failure.engine?.engine || failure.engine?.provider || failure.engine?.model) {
+      console.log(`  engine: ${failure.engine?.engine || "n/a"} | provider: ${failure.engine?.provider || "n/a"} | model: ${failure.engine?.model || "n/a"}`);
+    }
+    console.log(`  artifacts: ${failure.artifactDir}`);
+    console.log(`  rerun: ${rerunCommand(failure)}`);
+  }
+}
+
+if (summary.skippedTests?.length) {
+  console.log("\nSkipped tests:");
+  for (const skipped of summary.skippedTests) {
+    const freshness = assessTestFreshness(skipped, workspaceState, baselineWorkspaceState);
+    console.log(`- ${skipped.name}`);
+    console.log(`  file: ${skipped.file}`);
+    console.log(`  reason: ${skipped.reason_code} (${skipped.reason_summary})`);
+    console.log(`  reason: ${skipped.skip_reason}`);
+    console.log(`  freshness: ${freshness.status} (${freshness.rerun_advice})`);
+    if (freshness.changed_relevant_files?.length) {
+      console.log(`  blast radius: ${freshness.changed_relevant_files.join(", ")}`);
+    }
+    console.log(`  artifacts: ${skipped.artifactDir}`);
+    console.log(`  rerun: ${rerunCommand(skipped)}`);
+  }
+}
+
+if (fs.existsSync(markdownPath)) {
+  console.log(`\nMarkdown summary: ${markdownPath}`);
+}