@alecsibilia/luca 13.0.0-alpha.1

package/dist/shared/luca.C4gMUoBd.mjs

@@ -0,0 +1,358 @@
+import './luca.CRmaAfXR.mjs';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:crypto';
+import 'node:module';
+import 'node:url';
+import 'node:child_process';
+import { r as readConfidenceJournal, a as readLedgerForRun } from './luca.HZxBTBgD.mjs';
+import { l as listPhaseSlugs, r as readVerificationResult } from './luca.BmhNkYe2.mjs';
+
+function fingerprint(input) {
+  let hash = 0;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) - hash + input.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+const LOW_CONFIDENCE_THRESHOLD = 3;
+function eventDataString(e, key) {
+  const v = e.data[key];
+  return typeof v === "string" ? v : void 0;
+}
+function mostRecentPhaseAt(entries, at) {
+  const target = new Date(at).getTime();
+  let best;
+  for (const e of entries) {
+    if (e.event !== "phase-start") continue;
+    if (new Date(e.timestamp).getTime() > target) break;
+    const name = eventDataString(e, "phase");
+    if (name) best = name;
+  }
+  return best;
+}
+function analyzeRun(input) {
+  const { runId: targetRunId, entries, verifications, confidence } = input;
+  const startedAt = entries[0]?.timestamp;
+  const endedAt = entries[entries.length - 1]?.timestamp;
+  const durationMs = startedAt && endedAt ? new Date(endedAt).getTime() - new Date(startedAt).getTime() : void 0;
+  const phaseMap = /* @__PURE__ */ new Map();
+  function getPhase(name) {
+    let p = phaseMap.get(name);
+    if (!p) {
+      p = { name, verifications: [], todosMovedToDone: [] };
+      phaseMap.set(name, p);
+    }
+    return p;
+  }
+  for (const e of entries) {
+    const phaseName = eventDataString(e, "phase");
+    switch (e.event) {
+      case "phase-start": {
+        if (phaseName) getPhase(phaseName).startedAt = e.timestamp;
+        break;
+      }
+      case "phase-complete": {
+        if (phaseName) getPhase(phaseName).completedAt = e.timestamp;
+        break;
+      }
+      case "phase-diff-summary": {
+        if (!phaseName) break;
+        getPhase(phaseName).diff = {
+          filesChanged: Array.isArray(e.data.filesChanged) ? e.data.filesChanged : [],
+          commitsAdded: Array.isArray(e.data.commitsAdded) ? e.data.commitsAdded : [],
+          isEmpty: e.data.isEmpty === true,
+          indeterminate: e.data.indeterminate === true
+        };
+        break;
+      }
+      case "phase-empty-justification": {
+        if (!phaseName) break;
+        getPhase(phaseName).justification = {
+          category: eventDataString(e, "category") ?? "unknown",
+          reasoning: eventDataString(e, "reasoning") ?? "",
+          at: e.timestamp
+        };
+        break;
+      }
+      case "todo-moved-to-done": {
+        const recentPhase = mostRecentPhaseAt(entries, e.timestamp);
+        if (recentPhase) {
+          getPhase(recentPhase).todosMovedToDone.push({
+            slug: eventDataString(e, "slug") ?? "<unknown>",
+            verificationRef: e.data.verificationRef ?? null
+          });
+        }
+        break;
+      }
+    }
+  }
+  for (const v of verifications) {
+    if (v.phase) getPhase(v.phase).verifications.push(v);
+  }
+  const phases = Array.from(phaseMap.values());
+  const violations = [];
+  for (const p of phases) {
+    if (!p.completedAt) continue;
+    if (p.diff?.isEmpty && !p.justification) {
+      violations.push({
+        severity: "critical",
+        code: "EMPTY_PHASE_NO_JUSTIFICATION",
+        message: `Phase "${p.name}" completed with zero file changes and zero commits but has no phase-empty-justification entry.`,
+        evidence: `phase=${p.name} completedAt=${p.completedAt}`,
+        evidenceFingerprint: fingerprint(
+          `EMPTY_PHASE:${p.name}:${p.completedAt}`
+        )
+      });
+    }
+  }
+  const moveBlocked = entries.filter((e) => e.event === "todo-move-blocked");
+  for (const e of moveBlocked) {
+    violations.push({
+      severity: "warning",
+      code: "TODO_DONE_NO_VERIFICATION",
+      message: `Blocked attempt to move todo "${eventDataString(e, "identifier") ?? "?"}" to done without a valid verificationRef. Tool layer prevented the unsafe transition.`,
+      evidence: `reason=${eventDataString(e, "reason") ?? "?"} at=${e.timestamp}`,
+      evidenceFingerprint: fingerprint(
+        `TODO_BLOCKED:${eventDataString(e, "identifier") ?? ""}:${e.timestamp}`
+      )
+    });
+  }
+  for (const p of phases) {
+    for (const t of p.todosMovedToDone) {
+      if (!t.verificationRef) {
+        violations.push({
+          severity: "critical",
+          code: "TODO_DONE_NO_VERIFICATION",
+          message: `Todo "${t.slug}" moved to done without a verificationRef in phase "${p.name}".`,
+          evidence: `phase=${p.name} slug=${t.slug}`,
+          evidenceFingerprint: fingerprint(
+            `TODO_NOREF:${p.name}:${t.slug}`
+          )
+        });
+      }
+    }
+  }
+  const forced = entries.filter(
+    (e) => e.event === "pipeline-forced-transition"
+  );
+  for (const e of forced) {
+    violations.push({
+      severity: "warning",
+      code: "FORCED_TRANSITION",
+      message: `Pipeline-guard force-transitioned the agent (it failed to call switch-mode).`,
+      evidence: `from=${eventDataString(e, "from") ?? "?"} to=${eventDataString(e, "to") ?? "?"} at=${e.timestamp}`,
+      evidenceFingerprint: fingerprint(
+        `FORCED:${e.timestamp}:${eventDataString(e, "from") ?? ""}`
+      )
+    });
+  }
+  const lowConfidence = confidence.filter((c) => c.confidence === "low");
+  if (lowConfidence.length >= LOW_CONFIDENCE_THRESHOLD) {
+    violations.push({
+      severity: "warning",
+      code: "LOW_CONFIDENCE_THRESHOLD",
+      message: `${lowConfidence.length} low-confidence executor decisions (threshold=${LOW_CONFIDENCE_THRESHOLD}). Human review recommended before merge.`,
+      evidence: `count=${lowConfidence.length} categories=${lowConfidence.map((c) => c.category).join(",")}`,
+      evidenceFingerprint: fingerprint(
+        `LOWCONF:${lowConfidence.length}:${targetRunId}`
+      )
+    });
+  }
+  const waveBlocked = entries.filter(
+    (e) => e.event === "wave-advance-blocked"
+  );
+  for (const e of waveBlocked) {
+    violations.push({
+      severity: "warning",
+      code: "WAVE_NO_VERIFICATION",
+      message: `Blocked attempt to advance wave without verification-result. Tool layer prevented the unsafe transition.`,
+      evidence: `phase=${eventDataString(e, "phase") ?? "?"} wave=${e.data.wave ?? "?"} at=${e.timestamp}`,
+      evidenceFingerprint: fingerprint(
+        `WAVE_BLOCKED:${eventDataString(e, "phase") ?? ""}:${e.data.wave ?? ""}`
+      )
+    });
+  }
+  const reEntered = entries.filter((e) => e.event === "pipeline-re-entered");
+  for (const e of reEntered) {
+    violations.push({
+      severity: "warning",
+      code: "PIPELINE_RE_ENTERED",
+      message: `Pipeline was re-entered mid-run (often indicates rework).`,
+      evidence: `targetMode=${eventDataString(e, "targetMode") ?? "?"} reason=${eventDataString(e, "reason") ?? "?"}`,
+      evidenceFingerprint: fingerprint(
+        `REENTRY:${e.timestamp}:${eventDataString(e, "targetMode") ?? ""}`
+      )
+    });
+  }
+  const idleBypass = entries.filter(
+    (e) => e.event === "pipeline-guard-idle-bypass"
+  );
+  for (const e of idleBypass) {
+    violations.push({
+      severity: "warning",
+      code: "PIPELINE_GUARD_IDLE_BYPASS",
+      message: `Pipeline-guard skipped enforcement because pipelineStep was idle. May indicate stale state contamination.`,
+      evidence: `at=${e.timestamp}`,
+      evidenceFingerprint: fingerprint(`IDLE_BYPASS:${e.timestamp}`)
+    });
+  }
+  const emptyDetected = entries.filter(
+    (e) => e.event === "phase-empty-detected"
+  );
+  for (const e of emptyDetected) {
+    const fromStep = eventDataString(e, "from") ?? "?";
+    const toStep = eventDataString(e, "to") ?? "?";
+    const expected = eventDataString(e, "expectedArtifact") ?? "?";
+    const slug = eventDataString(e, "slug") ?? "?";
+    violations.push({
+      severity: "warning",
+      code: "STEP_ARTIFACT_MISSING",
+      message: `Step "${fromStep}" advanced to "${toStep}" without writing its expected artifact ("${expected}") \u2014 possible empty/skipped step.`,
+      evidence: `slug=${slug} expectedArtifact=${expected} at=${e.timestamp}`,
+      evidenceFingerprint: fingerprint(
+        `STEP_EMPTY:${slug}:${fromStep}:${e.timestamp}`
+      )
+    });
+  }
+  const metrics = {
+    totalEvents: entries.length,
+    modeTransitions: entries.filter((e) => e.event === "mode-transition").length,
+    phasesCompleted: entries.filter((e) => e.event === "phase-complete").length,
+    emptyPhasesJustified: entries.filter(
+      (e) => e.event === "phase-empty-justification"
+    ).length,
+    todosMovedToDone: entries.filter(
+      (e) => e.event === "todo-moved-to-done"
+    ).length,
+    lowConfidenceCount: lowConfidence.length,
+    forcedTransitions: forced.length,
+    moveBlockedCount: moveBlocked.length
+  };
+  const critical = violations.filter((v) => v.severity === "critical");
+  const pitfalls = critical.map((v) => ({
+    vault: "default",
+    concept: `pitfall:${v.code.toLowerCase().replace(/_/g, "-")}`,
+    type: "pitfall",
+    content: `## ${v.code}
+
+${v.message}
+
+**Evidence**: ${v.evidence}
+
+**Run**: ${targetRunId}`,
+    tags: ["luca", "pipeline", "postmortem", v.code.toLowerCase()],
+    op_id: `${targetRunId}:${v.code}:${v.evidenceFingerprint}`
+  }));
+  return {
+    runId: targetRunId,
+    startedAt,
+    endedAt,
+    durationMs,
+    phases,
+    violations,
+    metrics,
+    pitfalls
+  };
+}
+function computePostmortemExitCode(report) {
+  return report.violations.some((v) => v.severity === "critical") ? 1 : 0;
+}
+function renderPostmortemMarkdown(report) {
+  const lines = [];
+  lines.push(`# Postmortem \u2014 Run ${report.runId}`, "");
+  lines.push(`- **Started**: ${report.startedAt ?? "unknown"}`);
+  lines.push(`- **Ended**: ${report.endedAt ?? "unknown"}`);
+  if (report.durationMs !== void 0) {
+    lines.push(`- **Duration**: ${Math.round(report.durationMs / 6e4)} min`);
+  }
+  lines.push("");
+  const critical = report.violations.filter((v) => v.severity === "critical");
+  const warnings = report.violations.filter((v) => v.severity === "warning");
+  lines.push("## Violations", "");
+  lines.push(`- **Critical**: ${critical.length}`);
+  lines.push(`- **Warning**: ${warnings.length}`, "");
+  if (report.violations.length > 0) {
+    lines.push("| Severity | Code | Message |", "| --- | --- | --- |");
+    for (const v of report.violations) {
+      lines.push(
+        `| ${v.severity} | \`${v.code}\` | ${v.message.replace(/\|/g, "\\|")} |`
+      );
+    }
+    lines.push("");
+  }
+  lines.push("## Phases", "");
+  if (report.phases.length === 0) {
+    lines.push("_No phases recorded._", "");
+  }
+  for (const p of report.phases) {
+    lines.push(`### ${p.name}`, "");
+    lines.push(
+      `- Started: ${p.startedAt ?? "?"} | Completed: ${p.completedAt ?? "?"}`
+    );
+    if (p.diff) {
+      const status = p.diff.indeterminate ? "_(indeterminate \u2014 non-git or no snapshot)_" : p.diff.isEmpty ? "\u26A0 EMPTY" : `${p.diff.filesChanged.length} files, ${p.diff.commitsAdded.length} commits`;
+      lines.push(`- Diff: ${status}`);
+    }
+    if (p.justification) {
+      lines.push(
+        `- Empty-phase justification: \`${p.justification.category}\` \u2014 ${p.justification.reasoning}`
+      );
+    }
+    if (p.verifications.length > 0) {
+      lines.push(
+        `- Verifications: ${p.verifications.map((v) => `wave ${v.wave}: ${v.status}`).join(", ")}`
+      );
+    }
+    if (p.todosMovedToDone.length > 0) {
+      lines.push(
+        `- Todos moved to done: ${p.todosMovedToDone.map((t) => t.slug).join(", ")}`
+      );
+    }
+    lines.push("");
+  }
+  lines.push("## Metrics", "");
+  for (const [k, v] of Object.entries(report.metrics)) {
+    lines.push(`- **${k}**: ${v}`);
+  }
+  lines.push("");
+  lines.push("## What to do next", "");
+  if (critical.length > 0) {
+    lines.push(
+      "- \u{1F6D1} **Critical violations present.** Finalize cannot create a PR until these are resolved. Re-enter pipeline at execute or review."
+    );
+  } else if (warnings.length > 0) {
+    lines.push(
+      "- \u26A0 Warnings present but non-blocking. Review the table above before merging."
+    );
+  } else {
+    lines.push("- \u2705 No violations detected. Run is clean.");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+function gatherRunArtifacts(opts) {
+  const { cwd, runId } = opts;
+  const verifications = [];
+  const confidence = [];
+  for (const slug of listPhaseSlugs(cwd)) {
+    const verification = readVerificationResult({
+      cwd,
+      slug,
+      currentRunId: runId
+    });
+    if (verification) verifications.push(verification);
+    confidence.push(...readConfidenceJournal({ cwd, slug }));
+  }
+  return {
+    runId,
+    entries: readLedgerForRun({ cwd, runId }),
+    verifications,
+    confidence
+  };
+}
+
+export { analyzeRun as a, computePostmortemExitCode as c, gatherRunArtifacts as g, renderPostmortemMarkdown as r };

package/dist/shared/luca.CQ3g1xrD.mjs

@@ -0,0 +1,19 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+async function loadCurrentConfig(opts) {
+  const configPath = join(opts.cwd, ".luca", "config.json");
+  if (!existsSync(configPath)) return {};
+  try {
+    const raw = JSON.parse(await readFile(configPath, "utf-8"));
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      return raw;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+
+export { loadCurrentConfig as l };