@alecsibilia/luca 13.0.0-alpha.1

package/dist/chunks/muninndb-health.mjs

@@ -0,0 +1,66 @@
+import { h as checkMuninndbBinary, d as checkMuninndbService } from '../shared/luca.BYdjkfnz.mjs';
+import 'pathe';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:os';
+import 'zod';
+import '../shared/luca.DTomPq7I.mjs';
+import '@clack/prompts';
+import 'semver';
+
+const muninndbHealthCheck = {
+  name: "MuninnDB",
+  scope: "global",
+  async run() {
+    const binary = await checkMuninndbBinary();
+    if (!binary.installed) {
+      return {
+        name: this.name,
+        status: "fail",
+        message: "MuninnDB binary not found",
+        fixCommand: "luca init",
+        details: "MuninnDB binary not installed at ~/.luca/bin/muninndb. Run `luca init` to install it."
+      };
+    }
+    if (!binary.executable) {
+      return {
+        name: this.name,
+        status: "fail",
+        message: "MuninnDB binary not executable",
+        fixCommand: "chmod +x ~/.luca/bin/muninndb",
+        details: `Binary found at ${binary.path} but lacks executable permissions.`
+      };
+    }
+    const service = await checkMuninndbService();
+    if (!service.running) {
+      const versionSuffix2 = binary.version ? ` (${binary.version})` : "";
+      return {
+        name: this.name,
+        status: "warning",
+        message: `Binary installed${versionSuffix2}, service not running`,
+        fixCommand: "muninn start",
+        details: `Binary at ${binary.path}. Start the service with: muninn start`
+      };
+    }
+    if (!service.healthy) {
+      return {
+        name: this.name,
+        status: "warning",
+        message: `Service running on port ${service.port} but unhealthy`,
+        fixCommand: "Restart MuninnDB",
+        details: "MuninnDB process is running but failed the health check. Try restarting it."
+      };
+    }
+    const versionSuffix = binary.version ? ` (${binary.version})` : "";
+    const pidSuffix = service.pid ? `, PID ${service.pid}` : "";
+    return {
+      name: this.name,
+      status: "pass",
+      message: `Binary installed${versionSuffix}, service healthy (port ${service.port}${pidSuffix})`,
+      fixCommand: null,
+      details: null
+    };
+  }
+};
+
+export { muninndbHealthCheck };

package/dist/chunks/phase.mjs

@@ -0,0 +1,38 @@
+import { defineCommand } from 'citty';
+import 'zod';
+import '../shared/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 runWriteHandler, b as lucaPhaseCurrentTool } from '../shared/luca.DjDTeDCi.mjs';
+import 'node:os';
+import '../shared/luca.CrXzXueR.mjs';
+import '../shared/luca.HZxBTBgD.mjs';
+import '../shared/luca.TSMg1t7I.mjs';
+import '../shared/luca.CQ3g1xrD.mjs';
+import '../shared/luca.B3Mimc0P.mjs';
+
+const currentCommand = defineCommand({
+  meta: {
+    name: "current",
+    description: "Report the currently active phase: { active, NN, slug, dir }. Returns { active: false } when no phase is active. Use the `dir` field as the base for native Write-tool artifact paths. Pure read; allowed in every pipelineStep."
+  },
+  async run() {
+    await runWriteHandler("phase current", lucaPhaseCurrentTool, {});
+  }
+});
+const phaseCommand = defineCommand({
+  meta: {
+    name: "phase",
+    description: "Inspect the active Luca workflow phase"
+  },
+  subCommands: {
+    current: currentCommand
+  }
+});
+
+export { phaseCommand };

package/dist/chunks/pr-review.mjs

@@ -0,0 +1,122 @@
+import { defineCommand } from 'citty';
+import 'zod';
+import '../shared/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 { c as readJsonPayload, r as runWriteHandler, k as lucaPrReviewDetectConvergenceTool, m as lucaPrReviewFilterStaleTool, n as lucaPrReviewRegressionCheckTool } from '../shared/luca.DjDTeDCi.mjs';
+import 'node:os';
+import '../shared/luca.CrXzXueR.mjs';
+import '../shared/luca.HZxBTBgD.mjs';
+import '../shared/luca.TSMg1t7I.mjs';
+import '../shared/luca.CQ3g1xrD.mjs';
+import '../shared/luca.B3Mimc0P.mjs';
+
+const filterStaleCommand = defineCommand({
+  meta: {
+    name: "filter-stale",
+    description: "Classify PR review comments against the current working tree and drop those whose cited code has been rewritten. Pure read; phase-agnostic."
+  },
+  args: {
+    file: {
+      type: "string",
+      required: true,
+      description: "Path to a JSON file containing the comments array (gh api pulls/<n>/comments shape)."
+    },
+    "head-sha": {
+      type: "string",
+      description: "Override HEAD SHA used for stale detection. Defaults to current git HEAD."
+    },
+    "max-drift-lines": {
+      type: "string",
+      description: "Max line drift before a relocated anchor is treated as stale (default 5)."
+    }
+  },
+  async run({ args }) {
+    const comments = await readJsonPayload(
+      "pr-review filter-stale",
+      args.file
+    );
+    await runWriteHandler(
+      "pr-review filter-stale",
+      lucaPrReviewFilterStaleTool,
+      {
+        comments,
+        head_sha: args["head-sha"],
+        max_drift_lines: args["max-drift-lines"] !== void 0 ? Number(args["max-drift-lines"]) : void 0
+      }
+    );
+  }
+});
+const detectConvergenceCommand = defineCommand({
+  meta: {
+    name: "detect-convergence",
+    description: "Detect cross-perspective convergence: when 2+ independent reviewer perspectives flag the same location, promote weaker findings in that cluster to must-fix. Pure read; phase-agnostic."
+  },
+  args: {
+    file: {
+      type: "string",
+      required: true,
+      description: "Path to a JSON file containing the combined findings array across every reviewer perspective."
+    },
+    "line-tolerance": {
+      type: "string",
+      description: "Lines within +/- this distance count as the same location (default 2)."
+    }
+  },
+  async run({ args }) {
+    const findings = await readJsonPayload(
+      "pr-review detect-convergence",
+      args.file
+    );
+    await runWriteHandler(
+      "pr-review detect-convergence",
+      lucaPrReviewDetectConvergenceTool,
+      {
+        findings,
+        line_tolerance: args["line-tolerance"] !== void 0 ? Number(args["line-tolerance"]) : void 0
+      }
+    );
+  }
+});
+const regressionCheckCommand = defineCommand({
+  meta: {
+    name: "regression-check",
+    description: "Detect findings introduced by a fix iteration. Compares before/after finding snapshots and flags anything new on a touched path, or any severity escalation. Pure read; phase-agnostic. Exits 1 when regressions are present."
+  },
+  args: {
+    file: {
+      type: "string",
+      required: true,
+      description: "Path to a JSON file with the full payload: { before: Finding[], after: Finding[], touched_paths?: string[], from_sha?: string, to_sha?: string }."
+    }
+  },
+  async run({ args }) {
+    const payload = await readJsonPayload(
+      "pr-review regression-check",
+      args.file
+    );
+    await runWriteHandler(
+      "pr-review regression-check",
+      lucaPrReviewRegressionCheckTool,
+      payload
+    );
+  }
+});
+const prReviewCommand = defineCommand({
+  meta: {
+    name: "pr-review",
+    description: "Read-only PR-review analysis for the gh-pr-address flow"
+  },
+  subCommands: {
+    "filter-stale": filterStaleCommand,
+    "detect-convergence": detectConvergenceCommand,
+    "regression-check": regressionCheckCommand
+  }
+});
+
+export { prReviewCommand };

package/dist/chunks/preferences.mjs

@@ -0,0 +1,61 @@
+import { defineCommand } from 'citty';
+import 'zod';
+import '../shared/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 { c as readJsonPayload, r as runWriteHandler, f as lucaPreferencesReadTool, g as lucaPreferencesWriteTool } from '../shared/luca.DjDTeDCi.mjs';
+import 'node:os';
+import '../shared/luca.CrXzXueR.mjs';
+import '../shared/luca.HZxBTBgD.mjs';
+import '../shared/luca.TSMg1t7I.mjs';
+import '../shared/luca.CQ3g1xrD.mjs';
+import '../shared/luca.B3Mimc0P.mjs';
+
+const readCommand = defineCommand({
+  meta: {
+    name: "read",
+    description: "Read the project preferences object from .luca/config.json#preferences. Returns ProjectPreferencesSchema-validated JSON with defaults applied to unset sections. Pure read; allowed in every pipelineStep."
+  },
+  async run() {
+    await runWriteHandler("preferences read", lucaPreferencesReadTool, {});
+  }
+});
+const writeCommand = defineCommand({
+  meta: {
+    name: "write",
+    description: "Update the preferences section of .luca/config.json. Section-level shallow merge; other config keys are preserved. The merged result is validated against ProjectPreferencesSchema before write (rejects unsafe free-form input and ReDoS regex)."
+  },
+  args: {
+    file: {
+      type: "string",
+      required: true,
+      description: "Path to a JSON file containing the partial preferences object. Top-level sections (branching, commits, pr, release, tracker, schemaVersion) overlay existing ones; unspecified sections are left unchanged. Supplied as a file because the object may be large."
+    }
+  },
+  async run({ args }) {
+    const preferences = await readJsonPayload(
+      "preferences write",
+      args.file
+    );
+    await runWriteHandler("preferences write", lucaPreferencesWriteTool, {
+      preferences
+    });
+  }
+});
+const preferencesCommand = defineCommand({
+  meta: {
+    name: "preferences",
+    description: "Read and update Luca project preferences"
+  },
+  subCommands: {
+    read: readCommand,
+    write: writeCommand
+  }
+});
+
+export { preferencesCommand };

package/dist/chunks/repair.mjs

@@ -0,0 +1,111 @@
+import { defineCommand } from 'citty';
+import { existsSync } from 'node:fs';
+import { readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { l as lucaStateSchema } from '../shared/luca.CRmaAfXR.mjs';
+import 'node:crypto';
+import 'node:module';
+import 'node:url';
+import 'node:child_process';
+import 'zod';
+import 'node:os';
+
+async function runRepair(opts) {
+  const log = opts.log ?? (() => {
+  });
+  const lucaDir = join(opts.cwd, ".luca");
+  if (!existsSync(lucaDir)) {
+    return { actions: [], notes: [], errors: [] };
+  }
+  const actions = [];
+  const notes = [];
+  const errors = [];
+  const lockPath = join(lucaDir, "lock.json");
+  if (existsSync(lockPath)) {
+    try {
+      const raw = await readFile(lockPath, "utf-8");
+      const lock = JSON.parse(raw);
+      if (typeof lock.pid === "number" && isPidRunning(lock.pid)) {
+        const msg = `lock is held by running PID ${lock.pid}`;
+        notes.push(msg);
+        log(msg);
+      } else {
+        await rm(lockPath, { force: true });
+        const msg = `cleared stale lock (PID ${lock.pid ?? "unknown"})`;
+        actions.push(msg);
+        log(msg);
+      }
+    } catch (err) {
+      const msg = `failed to read lock.json: ${err.message}`;
+      errors.push(msg);
+      log(msg);
+    }
+  }
+  const statePath = join(lucaDir, "state.json");
+  if (existsSync(statePath)) {
+    try {
+      const raw = JSON.parse(await readFile(statePath, "utf-8"));
+      const parsed = lucaStateSchema.safeParse(raw);
+      if (!parsed.success) {
+        const msg = `state.json failed schema validation: ${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`;
+        errors.push(msg);
+        log(msg);
+      }
+    } catch (err) {
+      errors.push(
+        `state.json could not be parsed as JSON: ${err.message}`
+      );
+    }
+  }
+  return { actions, notes, errors };
+}
+function isPidRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === "EPERM") return true;
+    return false;
+  }
+}
+
+const repairCommand = defineCommand({
+  meta: {
+    name: "repair",
+    description: "Diagnose and recover the project .luca/ directory (clears stale locks, validates state)"
+  },
+  async run() {
+    const cwd = process.cwd();
+    const result = await runRepair({
+      cwd,
+      log: (msg) => {
+        console.log(`  ${msg}`);
+      }
+    });
+    if (result.actions.length === 0 && result.notes.length === 0 && result.errors.length === 0) {
+      console.log("Nothing to repair.");
+      return;
+    }
+    if (result.actions.length > 0) {
+      console.log("\n== Actions taken ==");
+      for (const action of result.actions) {
+        console.log(`  ${action}`);
+      }
+    }
+    if (result.notes.length > 0) {
+      console.log("\n== Notes (no repair needed) ==");
+      for (const note of result.notes) {
+        console.log(`  ${note}`);
+      }
+    }
+    if (result.errors.length > 0) {
+      console.log("\n== Errors (not auto-fixed) ==");
+      for (const err of result.errors) {
+        console.log(`  ${err}`);
+      }
+      process.exit(1);
+    }
+  }
+});
+
+export { repairCommand };

package/dist/chunks/repo.mjs

@@ -0,0 +1,58 @@
+import { defineCommand } from 'citty';
+import 'zod';
+import '../shared/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 { c as readJsonPayload, r as runWriteHandler, o as lucaRepoCleanupApplyTool } from '../shared/luca.DjDTeDCi.mjs';
+import 'node:os';
+import '../shared/luca.CrXzXueR.mjs';
+import '../shared/luca.HZxBTBgD.mjs';
+import '../shared/luca.TSMg1t7I.mjs';
+import '../shared/luca.CQ3g1xrD.mjs';
+import '../shared/luca.B3Mimc0P.mjs';
+
+const cleanupApplyCommand = defineCommand({
+  meta: {
+    name: "cleanup-apply",
+    description: "Apply a single remediation finding from a luca-shadow-scanner ShadowScanReport. The finding's recommended_action drives what gets applied (delete/move). Requires --confirm; phase-agnostic."
+  },
+  args: {
+    file: {
+      type: "string",
+      required: true,
+      description: "Path to a JSON file containing a single ShadowScanFinding object from a ShadowScanReport."
+    },
+    confirm: {
+      type: "boolean",
+      default: false,
+      description: "Must be passed to actually apply the remediation. Without it the command is a no-op preview so a stray call cannot delete or move files."
+    }
+  },
+  async run({ args }) {
+    const finding = await readJsonPayload("repo cleanup-apply", args.file);
+    await runWriteHandler(
+      "repo cleanup-apply",
+      lucaRepoCleanupApplyTool,
+      {
+        finding,
+        confirm: args.confirm
+      }
+    );
+  }
+});
+const repoCommand = defineCommand({
+  meta: {
+    name: "repo",
+    description: "Repository housekeeping for the Luca workflow"
+  },
+  subCommands: {
+    "cleanup-apply": cleanupApplyCommand
+  }
+});
+
+export { repoCommand };

package/dist/chunks/retro.mjs

@@ -0,0 +1,86 @@
+import { defineCommand } from 'citty';
+import '../shared/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 { a as analyzeRun, g as gatherRunArtifacts, r as renderPostmortemMarkdown, c as computePostmortemExitCode } from '../shared/luca.C4gMUoBd.mjs';
+import { l as listRuns } from '../shared/luca.HZxBTBgD.mjs';
+import { l as logger } from '../shared/luca.dM-MKlNE.mjs';
+import 'zod';
+import 'node:os';
+import '../shared/luca.BmhNkYe2.mjs';
+import '../shared/luca.TSMg1t7I.mjs';
+import 'pathe';
+import 'consola';
+
+const retroCommand = defineCommand({
+  meta: {
+    name: "retro",
+    description: "Generate a postmortem for a Luca pipeline run."
+  },
+  args: {
+    run: {
+      type: "string",
+      description: "Run id to analyze (default: the most recent run in the ledger)."
+    },
+    list: {
+      type: "boolean",
+      description: "List the runs recorded in .luca/ledger.jsonl."
+    },
+    json: {
+      type: "boolean",
+      description: "Emit the full PostmortemReport as JSON instead of Markdown."
+    }
+  },
+  run({ args }) {
+    const cwd = process.cwd();
+    const runs = listRuns({ cwd });
+    if (args.list) {
+      if (runs.length === 0) {
+        logger.info("No runs recorded in .luca/ledger.jsonl.");
+        return;
+      }
+      for (const r of runs) {
+        logger.info(
+          `${r.runId}  \u2014  ${r.eventCount} event(s), ${r.firstEvent} \u2192 ${r.lastEvent}`
+        );
+      }
+      return;
+    }
+    if (runs.length === 0) {
+      logger.warn(
+        "No runs recorded in .luca/ledger.jsonl \u2014 nothing to analyze."
+      );
+      return;
+    }
+    let runId = args.run;
+    if (!runId) {
+      runId = [...runs].sort(
+        (a, b) => b.lastEvent.localeCompare(a.lastEvent)
+      )[0]?.runId;
+    } else if (!runs.some((r) => r.runId === runId)) {
+      logger.error(`luca retro: run '${runId}' not found in the ledger.`);
+      process.exitCode = 1;
+      return;
+    }
+    if (!runId) {
+      logger.warn("Could not resolve a run to analyze.");
+      return;
+    }
+    const report = analyzeRun(gatherRunArtifacts({ cwd, runId }));
+    if (args.json) {
+      process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+    } else {
+      process.stdout.write(`${renderPostmortemMarkdown(report)}
+`);
+    }
+    process.exitCode = computePostmortemExitCode(report);
+  }
+});
+
+export { retroCommand };

package/dist/chunks/roadmap.mjs

@@ -0,0 +1,58 @@
+import { defineCommand } from 'citty';
+import 'zod';
+import '../shared/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 { c as readJsonPayload, r as runWriteHandler, d as lucaRoadmapReadTool, e as lucaRoadmapCreateTool } from '../shared/luca.DjDTeDCi.mjs';
+import 'node:os';
+import '../shared/luca.CrXzXueR.mjs';
+import '../shared/luca.HZxBTBgD.mjs';
+import '../shared/luca.TSMg1t7I.mjs';
+import '../shared/luca.CQ3g1xrD.mjs';
+import '../shared/luca.B3Mimc0P.mjs';
+
+const readCommand = defineCommand({
+  meta: {
+    name: "read",
+    description: "Read the roadmap array from .luca/state.json, plus currentPhase and totalPhases for context. Each entry is { name, deps, status, complexity? }. Pure read; allowed in every pipelineStep."
+  },
+  async run() {
+    await runWriteHandler("roadmap read", lucaRoadmapReadTool, {});
+  }
+});
+const createCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: "Replace the roadmap in .luca/state.json with a new ordered list of phases. Resets currentPhase to 0; updates totalPhases. Only callable in the idle or triage pipelineStep."
+  },
+  args: {
+    file: {
+      type: "string",
+      required: true,
+      description: "Path to a JSON file containing the phases array: [{ name, deps?, status?, complexity? }, ...]. The array may be large, so it is supplied as a file rather than a flag. Defaults applied: deps=[], status=pending."
+    }
+  },
+  async run({ args }) {
+    const phases = await readJsonPayload("roadmap create", args.file);
+    await runWriteHandler("roadmap create", lucaRoadmapCreateTool, {
+      phases
+    });
+  }
+});
+const roadmapCommand = defineCommand({
+  meta: {
+    name: "roadmap",
+    description: "Read and replace the Luca workflow roadmap"
+  },
+  subCommands: {
+    read: readCommand,
+    create: createCommand
+  }
+});
+
+export { roadmapCommand };