@alecsibilia/luca 13.0.0-alpha.1

package/dist/shared/luca.HZxBTBgD.mjs

@@ -0,0 +1,201 @@
+import { existsSync, readFileSync, mkdirSync, appendFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { e as lucaRootPaths, q as LedgerEntrySchema, r as ConfidenceEntrySchema } from './luca.CRmaAfXR.mjs';
+import { p as phasePathFor } from './luca.TSMg1t7I.mjs';
+
+function appendLedger(opts) {
+  const entry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    runId: opts.runId,
+    event: opts.event,
+    data: opts.data ?? {}
+  };
+  const p = join(opts.cwd, lucaRootPaths.ledger);
+  mkdirSync(dirname(p), { recursive: true });
+  appendFileSync(p, `${JSON.stringify(entry)}
+`, "utf-8");
+}
+function readLedger(opts) {
+  const p = join(opts.cwd, lucaRootPaths.ledger);
+  if (!existsSync(p)) return [];
+  try {
+    const content = readFileSync(p, "utf-8");
+    if (!content.trim()) return [];
+    const entries = [];
+    let lineNumber = 0;
+    for (const line of content.split("\n")) {
+      lineNumber += 1;
+      if (!line.trim()) continue;
+      let parsedJson;
+      try {
+        parsedJson = JSON.parse(line);
+      } catch {
+        console.warn(
+          `readLedger: skipping malformed JSON at ${p}:${lineNumber}`
+        );
+        continue;
+      }
+      const parsed = LedgerEntrySchema.safeParse(parsedJson);
+      if (parsed.success) {
+        entries.push(parsed.data);
+      } else {
+        console.warn(
+          `readLedger: skipping schema-invalid entry at ${p}:${lineNumber}`
+        );
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function readLedgerForRun(opts) {
+  return readLedger({ cwd: opts.cwd }).filter((e) => e.runId === opts.runId);
+}
+function listRuns(opts) {
+  const entries = readLedger({ cwd: opts.cwd });
+  const byRun = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const id = e.runId || "unknown";
+    const existing = byRun.get(id);
+    if (!existing) {
+      byRun.set(id, { first: e.timestamp, last: e.timestamp, count: 1 });
+    } else {
+      existing.last = e.timestamp;
+      existing.count += 1;
+    }
+  }
+  return Array.from(byRun.entries()).map(([runId, v]) => ({
+    runId,
+    firstEvent: v.first,
+    lastEvent: v.last,
+    eventCount: v.count
+  }));
+}
+
+function appendConfidenceEntry(opts) {
+  const full = {
+    ...opts.entry,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const p = join(opts.cwd, phasePathFor(opts.slug, "confidence"));
+  mkdirSync(dirname(p), { recursive: true });
+  appendFileSync(p, `${JSON.stringify(full)}
+`, "utf-8");
+  return full;
+}
+function readConfidenceJournal(opts) {
+  const p = join(opts.cwd, phasePathFor(opts.slug, "confidence"));
+  if (!existsSync(p)) return [];
+  const content = readFileSync(p, "utf-8");
+  if (!content.trim()) return [];
+  const entries = [];
+  const invalidLines = [];
+  for (const [index, line] of content.split("\n").entries()) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = ConfidenceEntrySchema.safeParse(JSON.parse(line));
+      if (parsed.success) {
+        entries.push(parsed.data);
+      } else {
+        invalidLines.push(index + 1);
+      }
+    } catch {
+      invalidLines.push(index + 1);
+    }
+  }
+  if (invalidLines.length > 0) {
+    const plural = invalidLines.length === 1;
+    console.warn(
+      `[confidence-journal] skipped ${invalidLines.length} invalid entr${plural ? "y" : "ies"} in ${p} at line${plural ? "" : "s"} ${invalidLines.join(", ")}.`
+    );
+  }
+  return entries;
+}
+function getConfidenceSummary(entries) {
+  const categories = {};
+  let high = 0;
+  let medium = 0;
+  let low = 0;
+  for (const entry of entries) {
+    if (entry.confidence === "high") high++;
+    else if (entry.confidence === "medium") medium++;
+    else low++;
+    categories[entry.category] = (categories[entry.category] ?? 0) + 1;
+  }
+  return { total: entries.length, high, medium, low, categories };
+}
+const CONFIDENCE_EMOJI = {
+  high: "\u{1F7E2}",
+  medium: "\u{1F7E1}",
+  low: "\u{1F534}"
+};
+function renderConfidenceJournalMarkdown(entries) {
+  if (entries.length === 0) {
+    return "# Confidence Journal\n\nNo entries recorded yet.\n";
+  }
+  const summary = getConfidenceSummary(entries);
+  const lines = [
+    "# Confidence Journal",
+    "",
+    "## Summary",
+    "",
+    "| Confidence | Count |",
+    "|------------|-------|",
+    `| \u{1F7E2} High   | ${summary.high} |`,
+    `| \u{1F7E1} Medium | ${summary.medium} |`,
+    `| \u{1F534} Low    | ${summary.low} |`,
+    ""
+  ];
+  const catParts = Object.entries(summary.categories).sort(([, a], [, b]) => b - a).map(([cat, count]) => `${cat} (${count})`);
+  if (catParts.length > 0) {
+    lines.push(`**Categories**: ${catParts.join(", ")}`, "");
+  }
+  if (summary.low > 0) {
+    lines.push(
+      `\u26A0\uFE0F **${summary.low} low-confidence decision${summary.low > 1 ? "s" : ""} require${summary.low === 1 ? "s" : ""} human review** \u2014 see entries marked \u{1F534} below.`,
+      ""
+    );
+  }
+  lines.push("---", "");
+  const byPhase = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = entry.phase || "Unspecified Phase";
+    const list = byPhase.get(key);
+    if (list) list.push(entry);
+    else byPhase.set(key, [entry]);
+  }
+  for (const [phase, phaseEntries] of byPhase) {
+    lines.push(`## ${phase}`, "");
+    for (const entry of phaseEntries) {
+      lines.push(
+        `### ${CONFIDENCE_EMOJI[entry.confidence]} Wave ${entry.wave}, ${entry.task}`,
+        "",
+        `- **Confidence**: ${entry.confidence}`,
+        `- **Category**: ${entry.category}`,
+        `- **Decision**: ${entry.decision}`
+      );
+      if (entry.alternatives.length > 0) {
+        lines.push(
+          `- **Alternatives**: ${entry.alternatives.join("; ")}`
+        );
+      }
+      lines.push(
+        `- **Reasoning**: ${entry.reasoning}`,
+        `- **Risk**: ${entry.risk}`
+      );
+      if (entry.files.length > 0) {
+        lines.push(
+          `- **Files**: ${entry.files.map((f) => `\`${f}\``).join(", ")}`
+        );
+      }
+      if (entry.reviewHint) {
+        lines.push(`- **Review hint**: ${entry.reviewHint}`);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+
+export { readLedgerForRun as a, renderConfidenceJournalMarkdown as b, appendConfidenceEntry as c, appendLedger as d, getConfidenceSummary as g, listRuns as l, readConfidenceJournal as r };

package/dist/shared/luca.TSMg1t7I.mjs

@@ -0,0 +1,10 @@
+import { x as PhaseSlugSchema, L as LUCA_DIR_ROOT, y as PHASE_FILE_PATHS } from './luca.CRmaAfXR.mjs';
+
+function phasePathFor(slug, file) {
+  PhaseSlugSchema.parse(slug);
+  const base = `${LUCA_DIR_ROOT}/phases/${slug}`;
+  if (!file) return base;
+  return `${base}/${PHASE_FILE_PATHS[file]}`;
+}
+
+export { phasePathFor as p };

package/dist/shared/luca.dM-MKlNE.mjs

@@ -0,0 +1,25 @@
+import { consola } from 'consola';
+
+const log = consola.withTag("luca");
+const logger = {
+  /** Starting a process */
+  start: (message) => log.start(message),
+  /** Success message */
+  success: (message) => log.success(message),
+  /** Informational message */
+  info: (message) => log.info(message),
+  /** Warning - not fatal but noteworthy */
+  warn: (message) => log.warn(message),
+  /** Error - operation failed */
+  error: (message) => log.error(message),
+  /** Debug - only in verbose mode */
+  debug: (message) => log.debug(message),
+  /** Boxed summary output */
+  box: (content) => consola.box(content),
+  /** Styled step indicator */
+  step: (number, total, message) => {
+    log.info(`[${number}/${total}] ${message}`);
+  }
+};
+
+export { logger as l };

package/dist/shared/luca.naWEcQ4B.mjs

@@ -0,0 +1,7 @@
+function generateRunId() {
+  const ts = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 10);
+  return `run_${ts}_${rand}`;
+}
+
+export { generateRunId as g };

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@alecsibilia/luca",
+  "description": "Luca — spec-driven agentic development workflow for Claude Code (umbrella; bundles luca-cli, luca-core, luca-tools)",
+  "version": "13.0.0-alpha.1",
+  "license": "Apache-2.0",
+  "author": "Alec Sibilia <sibilia.alec@gmail.com>",
+  "homepage": "https://github.com/asibilia/luca-framework#readme",
+  "bugs": {
+    "url": "https://github.com/asibilia/luca-framework/issues"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "bin": {
+    "luca": "./bin/luca.js"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.0",
+    "citty": "^0.2.0",
+    "consola": "^3.4.0",
+    "pathe": "^2.0.3",
+    "semver": "^7.6.0",
+    "shell-quote": "^1.8.3",
+    "update-notifier": "^7.3.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@alecsibilia/luca-cli": "0.1.0",
+    "@alecsibilia/luca-core": "0.1.0",
+    "@alecsibilia/luca-tools": "0.1.0",
+    "@types/bun": "latest",
+    "@types/semver": "^7.5.8",
+    "@types/shell-quote": "^1.7.5",
+    "@types/update-notifier": "^6.0.8",
+    "typescript": "^5.0.0",
+    "unbuild": "^3.5.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "agent",
+    "ai",
+    "cli",
+    "claude-code",
+    "luca",
+    "muninndb",
+    "workflow",
+    "spec-driven"
+  ],
+  "module": "./dist/index.mjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/asibilia/luca-framework.git",
+    "directory": "packages/luca"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "prepublishOnly": "bun run build",
+    "typecheck": "bunx --bun tsc --noEmit"
+  },
+  "type": "module",
+  "types": "./dist/index.d.mts"
+}