@alecsibilia/luca 13.0.0-alpha.1

package/dist/chunks/stray-local-install.mjs

@@ -0,0 +1,200 @@
+import { existsSync } from 'node:fs';
+import { rm, writeFile, readdir, rmdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import '../shared/luca.CRmaAfXR.mjs';
+import 'node:crypto';
+import 'node:module';
+import 'node:url';
+import 'node:child_process';
+import '../index.mjs';
+import { l as listBundledArtifacts } from '../shared/luca.B3saVjJm.mjs';
+import 'zod';
+import 'node:os';
+import 'citty';
+import 'pathe';
+
+const CHECK_NAME = "Stray local install";
+async function readJsonObject(path) {
+  try {
+    const file = Bun.file(path);
+    if (!await file.exists()) return null;
+    const parsed = JSON.parse(await file.text());
+    return parsed !== null && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function isStageGateEntry(entry) {
+  if (entry === null || typeof entry !== "object") return false;
+  const { hooks } = entry;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((h) => {
+    const command = h?.command;
+    return typeof command === "string" && command.includes("stage-gate");
+  });
+}
+async function scanStray(cwd) {
+  const claudeDir = join(cwd, ".claude");
+  const items = [];
+  if (!existsSync(claudeDir)) {
+    return { items, settingsStageGate: false };
+  }
+  const bundled = await listBundledArtifacts();
+  if (bundled) {
+    for (const name of bundled.commands) {
+      const path = join(claudeDir, "commands", name);
+      if (existsSync(path)) {
+        items.push({
+          path,
+          label: `.claude/commands/${name}`,
+          kind: "file"
+        });
+      }
+    }
+    for (const name of bundled.agents) {
+      const path = join(claudeDir, "agents", name);
+      if (existsSync(path)) {
+        items.push({
+          path,
+          label: `.claude/agents/${name}`,
+          kind: "file"
+        });
+      }
+    }
+    for (const name of bundled.skills) {
+      const path = join(claudeDir, "skills", name);
+      if (existsSync(path)) {
+        items.push({
+          path,
+          label: `.claude/skills/${name}/`,
+          kind: "dir"
+        });
+      }
+    }
+  }
+  const hookScript = join(claudeDir, "hooks", "stage-gate.sh");
+  if (existsSync(hookScript)) {
+    items.push({
+      path: hookScript,
+      label: ".claude/hooks/stage-gate.sh",
+      kind: "file"
+    });
+  }
+  const settings = await readJsonObject(join(claudeDir, "settings.json"));
+  const hooks = settings?.hooks;
+  const preToolUse = hooks !== null && typeof hooks === "object" ? hooks.PreToolUse : void 0;
+  const settingsStageGate = Array.isArray(preToolUse) && preToolUse.some(isStageGateEntry);
+  return { items, settingsStageGate };
+}
+async function stripStageGate(settingsPath) {
+  const settings = await readJsonObject(settingsPath);
+  if (!settings) return;
+  const hooks = settings.hooks;
+  if (hooks !== null && typeof hooks === "object") {
+    const hooksObj = hooks;
+    const preToolUse = hooksObj.PreToolUse;
+    if (Array.isArray(preToolUse)) {
+      const kept = preToolUse.filter((e) => !isStageGateEntry(e));
+      if (kept.length > 0) {
+        hooksObj.PreToolUse = kept;
+      } else {
+        delete hooksObj.PreToolUse;
+      }
+    }
+    if (Object.keys(hooksObj).length === 0) {
+      delete settings.hooks;
+    }
+  }
+  if (Object.keys(settings).length === 0) {
+    await rm(settingsPath, { force: true });
+    return;
+  }
+  await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+}
+async function pruneEmptyDirs(claudeDir, applied) {
+  for (const sub of ["commands", "agents", "skills", "hooks"]) {
+    const dir = join(claudeDir, sub);
+    if (existsSync(dir) && (await readdir(dir)).length === 0) {
+      await rmdir(dir);
+      applied.push(`removed empty .claude/${sub}/`);
+    }
+  }
+  if (existsSync(claudeDir) && (await readdir(claudeDir)).length === 0) {
+    await rmdir(claudeDir);
+    applied.push("removed empty .claude/");
+  }
+}
+const strayLocalInstallCheck = {
+  name: CHECK_NAME,
+  scope: "project",
+  async run() {
+    const { items, settingsStageGate } = await scanStray(process.cwd());
+    const count = items.length + (settingsStageGate ? 1 : 0);
+    if (count === 0) {
+      return {
+        name: CHECK_NAME,
+        status: "pass",
+        message: "no stray luca artifacts in ./.claude",
+        fixCommand: null,
+        details: null
+      };
+    }
+    const detailLines = [
+      "Through v12, `luca init` copied the luca skill set into this",
+      "repo. v13 installs it globally into ~/.claude/ \u2014 a repo should",
+      "hold only .luca/ planning files. Stray artifacts found:",
+      ...items.map((item) => `- ${item.label}`)
+    ];
+    if (settingsStageGate) {
+      detailLines.push("- .claude/settings.json (stage-gate hook entry)");
+    }
+    return {
+      name: CHECK_NAME,
+      status: "warning",
+      message: `${count} stray luca artifact(s) installed locally in ./.claude`,
+      fixCommand: "luca doctor --fix",
+      details: detailLines.join("\n  ")
+    };
+  },
+  async fix() {
+    const cwd = process.cwd();
+    const applied = [];
+    const errors = [];
+    const { items, settingsStageGate } = await scanStray(cwd);
+    for (const item of items) {
+      try {
+        await rm(item.path, {
+          recursive: item.kind === "dir",
+          force: true
+        });
+        applied.push(`removed ${item.label}`);
+      } catch (err) {
+        errors.push(
+          `could not remove ${item.label}: ${err.message}`
+        );
+      }
+    }
+    if (settingsStageGate) {
+      try {
+        await stripStageGate(join(cwd, ".claude", "settings.json"));
+        applied.push(
+          "removed stage-gate hook entry from .claude/settings.json"
+        );
+      } catch (err) {
+        errors.push(
+          `could not update .claude/settings.json: ${err.message}`
+        );
+      }
+    }
+    try {
+      await pruneEmptyDirs(join(cwd, ".claude"), applied);
+    } catch (err) {
+      errors.push(
+        `could not prune empty .claude/ directories: ${err.message}`
+      );
+    }
+    return { applied, errors };
+  }
+};
+
+export { strayLocalInstallCheck };

package/dist/chunks/telemetry.mjs

@@ -0,0 +1,165 @@
+import { defineCommand } from 'citty';
+import { R as RunIdSchema, L as LUCA_DIR_ROOT, T as TelemetryRecordSchema } from '../shared/luca.CRmaAfXR.mjs';
+import { mkdirSync, appendFileSync } from 'node:fs';
+import 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import 'node:crypto';
+import 'node:module';
+import 'node:url';
+import 'node:child_process';
+import { g as generateRunId } from '../shared/luca.naWEcQ4B.mjs';
+import { l as logger } from '../shared/luca.dM-MKlNE.mjs';
+import 'zod';
+import 'node:os';
+import 'consola';
+
+function telemetryPathFor(runId) {
+  RunIdSchema.parse(runId);
+  return `${LUCA_DIR_ROOT}/telemetry/${runId}.jsonl`;
+}
+
+function sanitizeForLog(value) {
+  return String(value instanceof Error ? value.message : value).replace(/[\r\n\t]/g, " ").slice(0, 200);
+}
+
+function buildTelemetryRecord(kind, ctx, meta = {}, overrides = {}) {
+  return {
+    v: 1,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    runId: overrides.runId ?? ctx.runId ?? "",
+    kind,
+    phase: overrides.phase ?? ctx.phase ?? null,
+    slug: overrides.slug ?? ctx.slug ?? null,
+    wave: overrides.wave ?? ctx.wave ?? null,
+    complexity: overrides.complexity ?? ctx.complexity ?? null,
+    oversight: overrides.oversight ?? ctx.oversight ?? null,
+    durationMs: overrides.durationMs ?? null,
+    meta
+  };
+}
+function appendTelemetry(opts) {
+  try {
+    const record = buildTelemetryRecord(
+      opts.kind,
+      opts.ctx,
+      opts.meta ?? {},
+      opts.overrides ?? {}
+    );
+    const parsed = TelemetryRecordSchema.safeParse(record);
+    if (!parsed.success) {
+      console.warn(
+        `[telemetry] dropped malformed record: ${sanitizeForLog(parsed.error.message)}`
+      );
+      return;
+    }
+    if (!parsed.data.runId) {
+      return;
+    }
+    const runIdCheck = RunIdSchema.safeParse(parsed.data.runId);
+    if (!runIdCheck.success) {
+      console.warn(
+        `[telemetry] dropped record with invalid runId: ${sanitizeForLog(runIdCheck.error.message)}`
+      );
+      return;
+    }
+    const p = join(opts.cwd, telemetryPathFor(parsed.data.runId));
+    mkdirSync(dirname(p), { recursive: true });
+    appendFileSync(p, `${JSON.stringify(parsed.data)}
+`, "utf-8");
+  } catch (err) {
+    console.warn(`[telemetry] write failed: ${sanitizeForLog(err)}`);
+  }
+}
+
+const emitCommand = defineCommand({
+  meta: {
+    name: "emit",
+    description: "Append one telemetry record to .luca/telemetry/<runId>.jsonl."
+  },
+  args: {
+    kind: {
+      type: "string",
+      required: true,
+      description: "Event kind, e.g. phase.start, wave.end, mode.start, recall.hit."
+    },
+    "run-id": {
+      type: "string",
+      required: true,
+      description: "Run identifier (see `luca telemetry new-run`)."
+    },
+    phase: { type: "string", description: "Phase name from the roadmap." },
+    slug: { type: "string", description: "Phase slug." },
+    wave: { type: "string", description: "Wave number." },
+    complexity: {
+      type: "string",
+      description: "Triage complexity classification."
+    },
+    oversight: { type: "string", description: "Oversight mode." },
+    "duration-ms": {
+      type: "string",
+      description: "Duration in milliseconds (for .end events)."
+    },
+    meta: {
+      type: "string",
+      description: "Free-form per-event metadata as a JSON object."
+    }
+  },
+  run({ args }) {
+    let meta = {};
+    if (args.meta) {
+      try {
+        const parsed = JSON.parse(args.meta);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+          throw new Error("not a JSON object");
+        }
+        meta = parsed;
+      } catch (err) {
+        logger.error(
+          `luca telemetry emit: --meta is not a valid JSON object \u2014 ${err instanceof Error ? err.message : String(err)}`
+        );
+        process.exitCode = 1;
+        return;
+      }
+    }
+    const ctx = {
+      runId: args["run-id"],
+      phase: args.phase ?? null,
+      slug: args.slug ?? null,
+      wave: args.wave !== void 0 ? Number(args.wave) : null,
+      complexity: args.complexity ?? null,
+      oversight: args.oversight ?? null
+    };
+    appendTelemetry({
+      cwd: process.cwd(),
+      kind: args.kind,
+      ctx,
+      meta,
+      overrides: args["duration-ms"] !== void 0 ? { durationMs: Number(args["duration-ms"]) } : {}
+    });
+    logger.success(
+      `telemetry: ${args.kind} emitted for run ${args["run-id"]}.`
+    );
+  }
+});
+const newRunCommand = defineCommand({
+  meta: {
+    name: "new-run",
+    description: "Mint and print a fresh telemetry run identifier."
+  },
+  run() {
+    process.stdout.write(`${generateRunId()}
+`);
+  }
+});
+const telemetryCommand = defineCommand({
+  meta: {
+    name: "telemetry",
+    description: "Emit Luca pipeline telemetry."
+  },
+  subCommands: {
+    emit: emitCommand,
+    "new-run": newRunCommand
+  }
+});
+
+export { telemetryCommand };

package/dist/chunks/todo.mjs

@@ -0,0 +1,151 @@
+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, h as lucaTodoUpdateTool, i as lucaTodoListTool, j as lucaTodoAddTool } 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 addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: "Create a new todo in MuninnDB. Validates the shape and emits a muninn_remember instruction for the agent to execute. Concept: todo:<id> in the repo vault. Phase-agnostic."
+  },
+  args: {
+    title: {
+      type: "string",
+      required: true,
+      description: "Short imperative description of the todo. Used to derive the id when --id is omitted."
+    },
+    body: {
+      type: "string",
+      description: "Optional longer markdown body \u2014 context, acceptance criteria, references."
+    },
+    status: {
+      type: "string",
+      default: "pending",
+      description: 'Initial status: "pending" or "backlog" (default pending). Promotion to "done" happens via `todo update`.'
+    },
+    source: {
+      type: "string",
+      description: 'Where the todo originated \u2014 e.g. "gh-issue-#42", "phase-research", "manual".'
+    },
+    id: {
+      type: "string",
+      description: "Optional explicit id (kebab-case). Derived from the title when omitted."
+    },
+    "metadata-file": {
+      type: "string",
+      description: "Optional path to a JSON file of arbitrary structured fields to store alongside the todo."
+    }
+  },
+  async run({ args }) {
+    const metadata = args["metadata-file"] ? await readJsonPayload("todo add", args["metadata-file"]) : void 0;
+    await runWriteHandler("todo add", lucaTodoAddTool, {
+      title: args.title,
+      body: args.body,
+      status: args.status,
+      source: args.source,
+      id: args.id,
+      metadata
+    });
+  }
+});
+const listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: 'List todos from MuninnDB. Emits a muninn_recall instruction with context ["todo:"] in the repo vault. Phase-agnostic.'
+  },
+  args: {
+    status: {
+      type: "string",
+      description: "Optional status filter (pending, backlog, done, ...). Applied by the agent post-recall."
+    },
+    limit: {
+      type: "string",
+      default: "50",
+      description: "Max todos to recall (range 1-200, default 50)."
+    }
+  },
+  async run({ args }) {
+    await runWriteHandler("todo list", lucaTodoListTool, {
+      status: args.status,
+      limit: Number(args.limit)
+    });
+  }
+});
+const updateCommand = defineCommand({
+  meta: {
+    name: "update",
+    description: 'Update an existing todo. Validates the new shape, enforces the verification-ref guard when promoting to "done", and emits a muninn_remember instruction. Phase-agnostic.'
+  },
+  args: {
+    id: {
+      type: "string",
+      required: true,
+      description: "Existing todo id (kebab-case). Used as the muninn concept suffix: todo:<id>."
+    },
+    title: {
+      type: "string",
+      required: true,
+      description: "Full title of the todo. Pass the existing title unchanged unless renaming."
+    },
+    status: {
+      type: "string",
+      required: true,
+      description: 'New status. Promoting to "done" requires --verification-criterion pointing at a met PASS criterion.'
+    },
+    body: {
+      type: "string",
+      description: "Optional updated markdown body."
+    },
+    source: {
+      type: "string",
+      description: "Optional updated origin label."
+    },
+    "verification-criterion": {
+      type: "string",
+      description: `Required when --status=done. A criterionId (e.g. "ac-03") in the active phase's verify.json that is met=true with non-empty evidence and parent status=PASS.`
+    },
+    "metadata-file": {
+      type: "string",
+      description: "Optional path to a JSON file of arbitrary structured fields to store alongside the todo."
+    }
+  },
+  async run({ args }) {
+    const metadata = args["metadata-file"] ? await readJsonPayload("todo update", args["metadata-file"]) : void 0;
+    const verificationRef = args["verification-criterion"] ? { criterionId: args["verification-criterion"] } : void 0;
+    await runWriteHandler("todo update", lucaTodoUpdateTool, {
+      id: args.id,
+      title: args.title,
+      status: args.status,
+      body: args.body,
+      source: args.source,
+      metadata,
+      verificationRef
+    });
+  }
+});
+const todoCommand = defineCommand({
+  meta: {
+    name: "todo",
+    description: "Manage the Luca development backlog (MuninnDB todos)"
+  },
+  subCommands: {
+    add: addCommand,
+    list: listCommand,
+    update: updateCommand
+  }
+});
+
+export { todoCommand };