@ludecker/aaac 1.1.6 → 1.2.0

package/templates/cursor/aaac/scripts/remediation/capture-wave-snapshot.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * Snapshot verify metrics immediately before a cleanup wave executes.
+ *
+ * Usage:
+ *   node capture-wave-snapshot.mjs --campaign-id <id> --iteration <n> --wave-index <w>
+ */
+import fs from "fs";
+import path from "path";
+import { spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+import { REPO_ROOT, isoNow, writeJson } from "../run-engine/lib.mjs";
+import { summarizeMetrics } from "./lib/verify-metrics.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CAMPAIGNS_ROOT = path.join(REPO_ROOT, ".cursor/aaac/state/campaigns");
+const VERIFY_SCRIPT = path.join(__dirname, "verify-remediation-iteration.mjs");
+
+function parseArgs(argv) {
+  const out = { campaignId: null, iteration: 0, waveIndex: 0 };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--campaign-id") out.campaignId = argv[++i];
+    else if (argv[i] === "--iteration") out.iteration = Number(argv[++i]);
+    else if (argv[i] === "--wave-index") out.waveIndex = Number(argv[++i]);
+  }
+  return out;
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.campaignId) {
+  console.error("capture-wave-snapshot: --campaign-id required");
+  process.exit(2);
+}
+
+spawnSync(
+  process.execPath,
+  [
+    VERIFY_SCRIPT,
+    "--campaign-id",
+    args.campaignId,
+    "--iteration",
+    String(args.iteration),
+    "--mode",
+    "wave",
+    "--label",
+    `pre-wave-${args.waveIndex}`,
+  ],
+  { encoding: "utf8" },
+);
+
+const iterDir = path.join(
+  CAMPAIGNS_ROOT,
+  args.campaignId,
+  "iterations",
+  String(args.iteration),
+);
+const prePath = path.join(iterDir, `wave-${args.waveIndex}-pre.json`);
+const verifyPath = path.join(iterDir, "verify-wave.json");
+
+let report = null;
+try {
+  report = JSON.parse(fs.readFileSync(verifyPath, "utf8"));
+} catch {
+  console.error("capture-wave-snapshot: missing verify-wave.json");
+  process.exit(2);
+}
+
+const snapshot = {
+  captured_at: isoNow(),
+  kind: "pre_wave",
+  wave_index: args.waveIndex,
+  iteration: args.iteration,
+  summary: summarizeMetrics(report),
+  metrics: report.metrics,
+};
+writeJson(prePath, snapshot);
+fs.copyFileSync(verifyPath, path.join(iterDir, `wave-${args.waveIndex}-pre-verify.json`));
+
+console.log(JSON.stringify({ ok: true, snapshot_path: prePath, summary: snapshot.summary }));

package/templates/cursor/aaac/scripts/remediation/check-swarm-raw.template.json

@@ -0,0 +1,26 @@
+{
+  "campaign_id": "campaign_EXAMPLE",
+  "iteration": 0,
+  "collected_at": "ISO8601",
+  "agents": [
+    {
+      "agent_id": "remediation-check-app-inventory",
+      "command_mirror": "check-app",
+      "answer": "partial",
+      "confidence": "high",
+      "false_positives": [
+        {
+          "path": "src/hooks/useCryptoPriceWorker.ts",
+          "export_name": null,
+          "reason": "worker_hook_runtime",
+          "evidence": "src/hooks/useCryptoPriceWorker.ts:1"
+        }
+      ],
+      "protected_paths": ["src/hooks/useCryptoPriceWorker.ts"],
+      "do_not_delete": [],
+      "safe_to_fix": [],
+      "findings": [],
+      "gaps": []
+    }
+  ]
+}

package/templates/cursor/aaac/scripts/remediation/classify-fallow-issues.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/**
+ * Classify Fallow scan findings and persist actionable vs false-positive SSOT.
+ *
+ * Usage:
+ *   node classify-fallow-issues.mjs --campaign-id <id> --iteration <n> [--save-actionable-baseline]
+ */
+import fs from "fs";
+import path from "path";
+import { REPO_ROOT, isoNow, readJson, writeJson } from "../run-engine/lib.mjs";
+import { classifyFallowScan, loadFpRules } from "./lib/fallow-classifier.mjs";
+
+const CAMPAIGNS_ROOT = path.join(REPO_ROOT, ".cursor/aaac/state/campaigns");
+
+function parseArgs(argv) {
+  const out = { campaignId: null, iteration: 0, saveActionableBaseline: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--campaign-id") out.campaignId = argv[++i];
+    else if (a === "--iteration") out.iteration = Number(argv[++i]);
+    else if (a === "--save-actionable-baseline") out.saveActionableBaseline = true;
+  }
+  return out;
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.campaignId) {
+  console.error("classify-fallow-issues: --campaign-id required");
+  process.exit(2);
+}
+
+const campaignDir = path.join(CAMPAIGNS_ROOT, args.campaignId);
+const iterDir = path.join(campaignDir, "iterations", String(args.iteration));
+const scanPath = path.join(iterDir, "fallow-scan.json");
+const scan = readJson(scanPath, null);
+
+if (!scan) {
+  console.error(`classify-fallow-issues: missing ${scanPath}`);
+  process.exit(2);
+}
+
+const classification = classifyFallowScan({
+  scan,
+  campaignDir,
+  rules: loadFpRules(),
+});
+
+const outPath = path.join(iterDir, "fallow-classification.json");
+writeJson(outPath, classification);
+
+const actionableBaselinePath = path.join(campaignDir, "fallow-start-actionable-baseline.json");
+if (args.saveActionableBaseline && !fs.existsSync(actionableBaselinePath)) {
+  writeJson(actionableBaselinePath, {
+    actionable_total: classification.summary.actionable_total,
+    raw_total: classification.summary.raw_total,
+    false_positive_total: classification.summary.false_positive_total,
+    recorded_at: isoNow(),
+    immutable: true,
+    source: "classify-fallow-issues",
+    iteration: args.iteration,
+  });
+}
+
+const campaign = readJson(path.join(campaignDir, "campaign.json"), null);
+if (campaign) {
+  campaign.current = campaign.current ?? {};
+  campaign.current.fallow_raw_total = classification.summary.raw_total;
+  campaign.current.fallow_actionable_total = classification.summary.actionable_total;
+  campaign.current.fallow_false_positive_total = classification.summary.false_positive_total;
+  campaign.updated_at = isoNow();
+  writeJson(path.join(campaignDir, "campaign.json"), campaign);
+}
+
+const journal = `\n- **Fallow classified** iter ${args.iteration}: raw=${classification.summary.raw_total}, actionable=${classification.summary.actionable_total}, false_positive=${classification.summary.false_positive_total}, review=${classification.summary.review_total}\n`;
+fs.appendFileSync(path.join(campaignDir, "journal.md"), journal);
+
+console.log(JSON.stringify({ ok: true, classification: classification.summary, path: outPath }));

package/templates/cursor/aaac/scripts/remediation/classify-verify-failure.mjs

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+/**
+ * Classify verify-remediation report failures → fix-module / fix-bug handoffs.
+ *
+ * Usage:
+ *   node classify-verify-failure.mjs --report <path> --campaign-id <id> [--iteration n] [--wave-index n] [--attempt n]
+ */
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { REPO_ROOT, readJson } from "../run-engine/lib.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RULES_PATH = path.join(__dirname, "dispatch-rules.json");
+
+function parseArgs(argv) {
+  const out = {
+    reportPath: null,
+    campaignId: "",
+    iteration: 0,
+    waveIndex: null,
+    attempt: 1,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--report") out.reportPath = argv[++i];
+    else if (a === "--campaign-id") out.campaignId = argv[++i];
+    else if (a === "--iteration") out.iteration = Number(argv[++i]);
+    else if (a === "--wave-index") out.waveIndex = Number(argv[++i]);
+    else if (a === "--attempt") out.attempt = Number(argv[++i]);
+  }
+  return out;
+}
+
+function loadRules() {
+  return readJson(RULES_PATH, { layers: {}, evidence_priority: [] });
+}
+
+function readLogFile(logPath) {
+  if (!logPath || !fs.existsSync(logPath)) return "";
+  try {
+    return fs.readFileSync(logPath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function evidenceText(step) {
+  if (!step) return "";
+  const fromLog = readLogFile(step.log_path);
+  if (fromLog) return fromLog;
+  return [
+    step.stdout_full,
+    step.stderr_full,
+    step.stderr_tail,
+    step.stdout_tail,
+    step.detail,
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+function extractFilePaths(text) {
+  const paths = new Set();
+  const patterns = [
+    /(?:frontend|backend)\/[^\s:'"]+\.(?:tsx?|jsx?|go)/g,
+    /src\/[^\s:'"]+\.(?:tsx?|jsx?)/g,
+    /internal\/[^\s:'"]+\.go/g,
+    /[^\s('"]+\.(?:test|spec)\.(?:tsx?|jsx?)/g,
+  ];
+  for (const re of patterns) {
+    for (const m of text.matchAll(re)) {
+      paths.add(m[0].replace(/^[('"]+/, ""));
+    }
+  }
+  return [...paths];
+}
+
+function inferDomain(layer, evidence, ruleDomain) {
+  const paths = extractFilePaths(evidence);
+  if (paths.some((p) => p.startsWith("backend/") || p.includes("/internal/") || p.endsWith(".go"))) {
+    return "backend";
+  }
+  if (paths.some((p) => p.startsWith("frontend/") || p.startsWith("src/"))) {
+    return "frontend";
+  }
+  return ruleDomain ?? "frontend";
+}
+
+function pickCommand(layer, rule, evidence) {
+  if (layer === "playwright" && /frontend not reachable|launch via/i.test(evidence)) {
+    return { command: null, level: "infrastructure", handoff: rule.layers?.playwright_infra?.handoff ?? "/launch-se100" };
+  }
+  if (layer === "playwright" && /does not provide an export|Failed to fetch dynamically imported module|Cannot find module/i.test(evidence)) {
+    return { command: rule.module_import_command ?? "fix-module", level: "code" };
+  }
+  if (layer === "vitest" && /\.(test|spec)\.(tsx?|jsx?)/.test(evidence) && !/src\/(?!.*\.test\.)/.test(evidence.split("\n")[0] ?? "")) {
+    return { command: rule.test_file_command ?? rule.command, level: "test" };
+  }
+  return { command: rule.command, level: rule.level ?? "code" };
+}
+
+function fillTemplate(template, vars) {
+  return template.replace(/\{(\w+)\}/g, (_, key) => String(vars[key] ?? ""));
+}
+
+function classifyReport(report, ctx) {
+  const rules = loadRules();
+  const failedLayers = rules.evidence_priority.filter((layer) => report[layer]?.status === "fail");
+  const handoffs = [];
+
+  for (const layer of failedLayers) {
+    const rule = rules.layers[layer];
+    if (!rule) continue;
+    const evidence = evidenceText(report[layer]);
+    const picked = pickCommand(layer, rule, evidence);
+    if (picked.level === "infrastructure") {
+      handoffs.push({
+        layer,
+        level: "infrastructure",
+        command: null,
+        domain: null,
+        intent: null,
+        handoff: picked.handoff,
+        evidence: evidence.slice(0, 16000),
+        evidence_truncated: evidence.length > 16000,
+        log_path: report[layer]?.log_path ?? null,
+        file_paths: extractFilePaths(evidence),
+      });
+      continue;
+    }
+    const domain = inferDomain(layer, evidence, rule.domain);
+    const intent = fillTemplate(rule.intent_template, {
+      campaign_id: ctx.campaignId,
+      iteration: ctx.iteration,
+      wave_index: ctx.waveIndex ?? "n/a",
+      attempt: ctx.attempt,
+      evidence: evidence.slice(0, 16000),
+    });
+    handoffs.push({
+      layer,
+      level: picked.level,
+      command: picked.command,
+      domain,
+      intent,
+      slash_command: `/${picked.command} ${domain} "${intent.replace(/"/g, '\\"').slice(0, 500)}…"`,
+      evidence: evidence.slice(0, 16000),
+      evidence_truncated: evidence.length > 16000,
+      log_path: report[layer]?.log_path ?? null,
+      file_paths: extractFilePaths(evidence),
+    });
+  }
+
+  return {
+    status: handoffs.length ? "fail" : "pass",
+    failed_layers: failedLayers,
+    handoffs,
+    primary: handoffs.find((h) => h.command) ?? handoffs[0] ?? null,
+  };
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.reportPath) {
+  console.error("classify-verify-failure: --report required");
+  process.exit(2);
+}
+
+const report = readJson(args.reportPath, null);
+if (!report) {
+  console.error(`classify-verify-failure: cannot read report ${args.reportPath}`);
+  process.exit(2);
+}
+
+const classification = classifyReport(report, args);
+console.log(JSON.stringify({ ok: true, classification }));
+process.exit(classification.status === "pass" ? 0 : 1);