@alecsibilia/luca 13.0.0-alpha.1

package/dist/chunks/confidence.mjs

@@ -0,0 +1,199 @@
+import { defineCommand } from 'citty';
+import '../shared/luca.CRmaAfXR.mjs';
+import { l as loadCurrentState, r as resolveActiveSlug } from '../shared/luca.CrXzXueR.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 { b as renderConfidenceJournalMarkdown, r as readConfidenceJournal, g as getConfidenceSummary } from '../shared/luca.HZxBTBgD.mjs';
+import { l as logger } from '../shared/luca.dM-MKlNE.mjs';
+import 'zod';
+import { c as readJsonPayload, r as runWriteHandler, t as lucaConfidenceLogTool } from '../shared/luca.DjDTeDCi.mjs';
+import 'node:os';
+import '../shared/luca.TSMg1t7I.mjs';
+import 'consola';
+import '../shared/luca.CQ3g1xrD.mjs';
+import '../shared/luca.B3Mimc0P.mjs';
+
+async function resolveSlug(opts) {
+  if (opts.explicit) return opts.explicit;
+  const state = await loadCurrentState({ cwd: opts.cwd });
+  const r = resolveActiveSlug(state);
+  if (!r.ok) {
+    logger.error(`luca confidence: ${r.error}`);
+    process.exit(1);
+  }
+  return r.slug;
+}
+function splitCsv(input) {
+  if (!input) return [];
+  return input.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+const logCommand = defineCommand({
+  meta: {
+    name: "log",
+    description: "Append a confidence entry to the active phase's confidence.jsonl (one JSONL line per call). Payload uses the canonical ConfidenceEntrySchema shape (phase, wave, task, confidence, category, decision, alternatives, reasoning, risk, files, reviewHint?). Phase-agnostic, but an active phase must exist."
+  },
+  args: {
+    // File-driven input (preferred for structured callers)
+    file: {
+      type: "string",
+      description: "Path to a JSON payload matching the canonical ConfidenceEntrySchema shape (minus `timestamp`, which is server-stamped). When set, all other flags below are ignored."
+    },
+    // Flag-driven input (every field is also a CLI flag)
+    phase: {
+      type: "string",
+      description: "Phase name from the plan / roadmap."
+    },
+    wave: {
+      type: "string",
+      description: "Wave number within the phase (parsed as a number)."
+    },
+    task: {
+      type: "string",
+      description: "Task ID or description from the plan."
+    },
+    confidence: {
+      type: "string",
+      description: "high | medium | low."
+    },
+    category: {
+      type: "string",
+      description: "One of: plan-gap, design-choice, convention-unclear, requirement-ambiguous, dependency-unknown, scope-creep."
+    },
+    decision: {
+      type: "string",
+      description: "What the executor actually decided to do."
+    },
+    alternatives: {
+      type: "string",
+      description: 'Comma-separated list of other options considered (e.g. `--alternatives="a,b,c"`).'
+    },
+    reasoning: {
+      type: "string",
+      description: "Why this choice was made over the alternatives."
+    },
+    risk: {
+      type: "string",
+      description: "What could go wrong if this was the wrong call."
+    },
+    files: {
+      type: "string",
+      description: 'Comma-separated list of files affected by this decision (e.g. `--files="src/a.ts,src/b.ts"`).'
+    },
+    "review-hint": {
+      type: "string",
+      description: "Optional. Suggested focus area for a human reviewer."
+    }
+  },
+  async run({ args }) {
+    let payload;
+    if (args.file) {
+      const fromFile = await readJsonPayload("confidence log", args.file);
+      if (typeof fromFile !== "object" || fromFile === null || Array.isArray(fromFile)) {
+        logger.error(
+          `luca confidence log: --file payload must be a JSON object.`
+        );
+        process.exit(1);
+      }
+      payload = fromFile;
+    } else {
+      payload = {
+        phase: args.phase,
+        wave: args.wave !== void 0 ? Number(args.wave) : void 0,
+        task: args.task,
+        confidence: args.confidence,
+        category: args.category,
+        decision: args.decision,
+        alternatives: splitCsv(args.alternatives),
+        reasoning: args.reasoning,
+        risk: args.risk,
+        files: splitCsv(args.files),
+        ...args["review-hint"] !== void 0 ? { reviewHint: args["review-hint"] } : {}
+      };
+    }
+    await runWriteHandler(
+      "confidence log",
+      lucaConfidenceLogTool,
+      payload
+    );
+  }
+});
+const readCommand = defineCommand({
+  meta: {
+    name: "read",
+    description: "Read every entry in a phase's confidence.jsonl as a JSON array."
+  },
+  args: {
+    slug: {
+      type: "string",
+      description: "Phase slug to read (default: the active phase)."
+    }
+  },
+  async run({ args }) {
+    const cwd = process.cwd();
+    const slug = await resolveSlug({ explicit: args.slug, cwd });
+    const entries = readConfidenceJournal({ cwd, slug });
+    process.stdout.write(`${JSON.stringify(entries, null, 2)}
+`);
+  }
+});
+const summaryCommand = defineCommand({
+  meta: {
+    name: "summary",
+    description: "Print aggregate counts (total / high / medium / low / categories) for a phase's confidence journal."
+  },
+  args: {
+    slug: {
+      type: "string",
+      description: "Phase slug to summarize (default: the active phase)."
+    }
+  },
+  async run({ args }) {
+    const cwd = process.cwd();
+    const slug = await resolveSlug({ explicit: args.slug, cwd });
+    const summary = getConfidenceSummary(
+      readConfidenceJournal({ cwd, slug })
+    );
+    process.stdout.write(`${JSON.stringify(summary, null, 2)}
+`);
+  }
+});
+const renderCommand = defineCommand({
+  meta: {
+    name: "render",
+    description: "Render a phase's confidence journal as Markdown (stdout)."
+  },
+  args: {
+    slug: {
+      type: "string",
+      description: "Phase slug to render (default: the active phase)."
+    }
+  },
+  async run({ args }) {
+    const cwd = process.cwd();
+    const slug = await resolveSlug({ explicit: args.slug, cwd });
+    const md = renderConfidenceJournalMarkdown(
+      readConfidenceJournal({ cwd, slug })
+    );
+    process.stdout.write(`${md}
+`);
+  }
+});
+const confidenceCommand = defineCommand({
+  meta: {
+    name: "confidence",
+    description: "Read and write the active phase's Luca confidence journal"
+  },
+  subCommands: {
+    log: logCommand,
+    read: readCommand,
+    summary: summaryCommand,
+    render: renderCommand
+  }
+});
+
+export { confidenceCommand };

package/dist/chunks/doctor.mjs

@@ -0,0 +1,158 @@
+import { defineCommand } from 'citty';
+import { l as logger } from '../shared/luca.dM-MKlNE.mjs';
+import 'consola';
+
+async function executeDoctor(options = {}) {
+  const { verbose = false, scope, fix = false } = options;
+  logger.info("Running environment diagnostics...\n");
+  const { bunRuntimeCheck } = await import('./bun-runtime.mjs');
+  const { muninndbHealthCheck } = await import('./muninndb-health.mjs');
+  const { staleMcpServerCheck } = await import('./stale-mcp-server.mjs');
+  const { strayLocalInstallCheck } = await import('./stray-local-install.mjs');
+  const allChecks = [
+    // Prerequisites
+    bunRuntimeCheck,
+    staleMcpServerCheck,
+    // Global
+    muninndbHealthCheck,
+    // Project (cwd-dependent)
+    strayLocalInstallCheck
+  ];
+  const checks = scope ? allChecks.filter((check) => check.scope === scope) : allChecks;
+  if (checks.length === 0) {
+    logger.warn(`No checks found for scope: ${scope}`);
+    return 0;
+  }
+  const scopeLabel = scope ? ` (scope: ${scope})` : "";
+  const results = await Promise.all(checks.map((check) => check.run()));
+  const passCount = results.filter((r) => r.status === "pass").length;
+  const failCount = results.filter((r) => r.status === "fail").length;
+  const warningCount = results.filter((r) => r.status === "warning").length;
+  logger.info(`Environment Diagnostics${scopeLabel}`);
+  logger.info("=".repeat(50));
+  for (const result of results) {
+    const icon = result.status === "pass" ? "+" : result.status === "fail" ? "x" : "!";
+    const logLine = `${icon} ${result.name}: ${result.message}`;
+    if (result.status === "pass") {
+      logger.success(logLine);
+    } else if (result.status === "fail") {
+      logger.error(logLine);
+    } else {
+      logger.warn(logLine);
+    }
+    if (result.details && (verbose || result.status !== "pass")) {
+      logger.info(`  ${result.details}`);
+    }
+  }
+  logger.info("");
+  logger.info("=".repeat(50));
+  logger.info(
+    `Results: ${passCount} passing, ${failCount} failing, ${warningCount} warning(s)`
+  );
+  if (fix) {
+    await applyFixes(checks, results);
+  } else {
+    const fixableChecks = results.filter(
+      (r) => (r.status === "fail" || r.status === "warning") && r.fixCommand
+    );
+    if (fixableChecks.length > 0) {
+      logger.info("");
+      logger.info("Suggested fixes:");
+      logger.info("-".repeat(50));
+      for (const check of fixableChecks) {
+        if (check.fixCommand) {
+          logger.info(`  ${check.name}:`);
+          logger.info(`  ${check.fixCommand}`);
+        }
+      }
+    }
+  }
+  logger.info("");
+  if (failCount > 0) {
+    if (!verbose) {
+      logger.error(
+        "Some checks failed. Run with --verbose for more details."
+      );
+    } else {
+      logger.error("Some checks failed.");
+    }
+    return 1;
+  }
+  if (warningCount > 0) {
+    logger.warn("All checks passed with warnings.");
+    return 0;
+  }
+  logger.success("All checks passed! Your environment is ready.");
+  return 0;
+}
+async function applyFixes(checks, results) {
+  const fixable = checks.map((check, index) => ({ check, result: results[index] })).filter(
+    (pair) => pair.result !== void 0 && pair.result.status !== "pass" && typeof pair.check.fix === "function"
+  );
+  if (fixable.length === 0) {
+    const hasIssues = results.some((result) => result.status !== "pass");
+    if (hasIssues) {
+      logger.info("");
+      logger.info("No automatic fixes available for the issues above.");
+    }
+    return;
+  }
+  logger.info("");
+  logger.info("Applying fixes (--fix)");
+  logger.info("-".repeat(50));
+  for (const { check } of fixable) {
+    const fixResult = await check.fix();
+    for (const action of fixResult.applied) {
+      logger.success(`+ ${check.name}: ${action}`);
+    }
+    for (const error of fixResult.errors) {
+      logger.error(`x ${check.name}: ${error}`);
+    }
+    if (fixResult.applied.length === 0 && fixResult.errors.length === 0) {
+      logger.info(`  ${check.name}: nothing to fix`);
+    }
+  }
+}
+
+const VALID_SCOPES = ["prerequisites", "global", "project"];
+const doctor = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Run environment diagnostics and health checks"
+  },
+  args: {
+    verbose: {
+      type: "boolean",
+      description: "Show detailed check information",
+      alias: "v",
+      default: false
+    },
+    scope: {
+      type: "string",
+      description: "Filter checks by scope: prerequisites, global, or project",
+      alias: "s"
+    },
+    fix: {
+      type: "boolean",
+      description: "Apply automatic fixes for issues that support remediation (e.g. stray local installs)",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const scope = args.scope;
+    if (scope && !VALID_SCOPES.includes(scope)) {
+      console.error(
+        `Invalid --scope value: "${scope}". Valid options: ${VALID_SCOPES.join(", ")}`
+      );
+      process.exit(1);
+    }
+    const exitCode = await executeDoctor({
+      verbose: args.verbose,
+      scope,
+      fix: args.fix
+    });
+    process.exit(exitCode);
+  }
+});
+
+export { doctor as default };