@alecsibilia/luca 13.0.0-alpha.1

package/dist/chunks/vault-init.mjs

@@ -0,0 +1,300 @@
+import { existsSync, chmodSync, mkdirSync } from 'node:fs';
+import '../shared/luca.CRmaAfXR.mjs';
+import 'node:fs/promises';
+import 'node:path';
+import { l as loadCurrentConfig } from '../shared/luca.CQ3g1xrD.mjs';
+import 'node:crypto';
+import 'node:module';
+import 'node:url';
+import 'node:child_process';
+import * as p from '@clack/prompts';
+import { defineCommand } from 'citty';
+import { join, basename } from 'pathe';
+import { z } from 'zod';
+import { d as checkMuninndbService, c as resolveMuninndbPort } from '../shared/luca.BYdjkfnz.mjs';
+import 'node:os';
+import '../shared/luca.DTomPq7I.mjs';
+import 'semver';
+
+function sanitizeVaultName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+
+async function detectProjectContext(cwd = process.cwd()) {
+  const context = {
+    hasPackageJson: false,
+    hasGit: false,
+    hasLuca: false,
+    detectedStack: "unknown",
+    hasTypeScript: false,
+    projectName: null
+  };
+  const pkgPath = join(cwd, "package.json");
+  try {
+    const pkgFile = Bun.file(pkgPath);
+    if (await pkgFile.exists()) {
+      const pkg = JSON.parse(await pkgFile.text());
+      context.hasPackageJson = true;
+      context.projectName = typeof pkg.name === "string" ? pkg.name : null;
+      context.projectDescription = typeof pkg.description === "string" ? pkg.description : null;
+      const deps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+      };
+      if (deps["react"] || deps["@types/react"]) {
+        context.detectedStack = deps["typescript"] ? "react-ts" : "react";
+      } else if (deps["typescript"]) {
+        context.detectedStack = "node-ts";
+      } else if (context.hasPackageJson) {
+        context.detectedStack = "node";
+      }
+      context.hasTypeScript = !!(deps["typescript"] || await Bun.file(join(cwd, "tsconfig.json")).exists());
+    }
+  } catch {
+  }
+  context.hasGit = existsSync(join(cwd, ".git"));
+  context.hasLuca = existsSync(join(cwd, ".luca"));
+  context.hasExistingSource = existsSync(join(cwd, "src")) || existsSync(join(cwd, "app")) || existsSync(join(cwd, "lib"));
+  return context;
+}
+
+const DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function stripPrototypeKeys(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(stripPrototypeKeys);
+  }
+  const cleaned = {};
+  for (const key of Object.keys(obj)) {
+    if (!DANGEROUS_KEYS.has(key)) {
+      cleaned[key] = stripPrototypeKeys(
+        obj[key]
+      );
+    }
+  }
+  return cleaned;
+}
+function sanitizeJsonParse(json) {
+  const parsed = JSON.parse(json);
+  return stripPrototypeKeys(parsed);
+}
+
+const VaultConfigSchema = z.object({
+  /** Sanitized vault name in lowercase kebab-case. */
+  vaultName: z.string().min(1),
+  /** MuninnDB API key for authentication. */
+  apiKey: z.string().min(1)
+});
+const MUNINNDB_WEB_UI_URL = "http://localhost:8477";
+function suggestVaultName(context, cwd = process.cwd()) {
+  const raw = context.projectName ?? basename(cwd);
+  return sanitizeVaultName(raw);
+}
+async function runVaultWizard(context, cwd = process.cwd()) {
+  const suggested = suggestVaultName(context, cwd);
+  const serviceStatus = await checkMuninndbService();
+  if (!serviceStatus.healthy) {
+    p.log.warn(
+      "MuninnDB is not running. Vault setup requires MuninnDB to be active."
+    );
+    p.log.info(
+      "Start MuninnDB and run `luca vault:init` to complete vault setup."
+    );
+    return null;
+  }
+  p.log.info("MuninnDB Vault Setup");
+  p.log.message(
+    "MuninnDB provides cognitive memory for Luca -- patterns, decisions, and pitfalls persist across sessions."
+  );
+  const vaultName = await p.text({
+    message: "Vault name",
+    placeholder: suggested,
+    defaultValue: suggested,
+    validate: (value) => {
+      const sanitized = sanitizeVaultName(value ?? "");
+      if (sanitized.length === 0) {
+        return "Vault name must contain at least one alphanumeric character.";
+      }
+    }
+  });
+  if (p.isCancel(vaultName)) return null;
+  const finalVaultName = sanitizeVaultName(String(vaultName));
+  p.note(
+    [
+      "To generate an API key, open the MuninnDB Web UI:",
+      "",
+      `  ${MUNINNDB_WEB_UI_URL}`,
+      "",
+      "Navigate to Settings > API Keys and create a new key.",
+      "If MuninnDB is not running, you can set this up later."
+    ].join("\n"),
+    "API Key"
+  );
+  const apiKey = await p.password({
+    message: "MuninnDB API key (leave empty to skip)"
+  });
+  if (p.isCancel(apiKey)) return null;
+  const trimmedKey = String(apiKey ?? "").trim();
+  if (trimmedKey.length === 0) {
+    p.log.warn(
+      "No API key provided. You can set MUNINN_API_KEY in .env later."
+    );
+    return null;
+  }
+  const confirmed = await p.confirm({
+    message: `Set vault "${finalVaultName}" with the provided API key?`,
+    initialValue: true
+  });
+  if (p.isCancel(confirmed) || !confirmed) return null;
+  const parseResult = VaultConfigSchema.safeParse({
+    vaultName: finalVaultName,
+    apiKey: trimmedKey
+  });
+  if (!parseResult.success) {
+    p.log.error("Invalid vault configuration. Please try again.");
+    return null;
+  }
+  return parseResult.data;
+}
+async function writeVaultConfig(vaultName, configPath) {
+  let config = {};
+  const file = Bun.file(configPath);
+  if (await file.exists()) {
+    try {
+      config = sanitizeJsonParse(await file.text());
+    } catch {
+    }
+  }
+  const existing = typeof config.muninn === "object" && config.muninn !== null ? config.muninn : {};
+  config.muninn = { ...existing, vault: vaultName };
+  await Bun.write(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+async function writeApiKeyToEnv(apiKey, envPath, vaultName) {
+  const vaultKey = vaultName ? `MUNINN_DB_${vaultName.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY` : "MUNINN_DB_API_KEY";
+  const envLines = [
+    `${vaultKey}=${apiKey}`,
+    // Default vault key is always needed for cross-cutting memories
+    ...vaultName && vaultName !== "default" ? [`MUNINN_DB_DEFAULT_API_KEY=${apiKey}`] : [],
+    `MUNINN_DB_API_KEY=${apiKey}`
+  ];
+  const file = Bun.file(envPath);
+  if (await file.exists()) {
+    let content = await file.text();
+    for (const envLine of envLines) {
+      const keyName = envLine.split("=")[0];
+      const lines = content.split("\n");
+      const existingIndex = lines.findIndex(
+        (line) => line.startsWith(`${keyName}=`)
+      );
+      if (existingIndex >= 0) {
+        lines[existingIndex] = envLine;
+        content = lines.join("\n");
+      } else {
+        const separator = content.endsWith("\n") ? "" : "\n";
+        content = content + separator + envLine + "\n";
+      }
+    }
+    await Bun.write(envPath, content);
+  } else {
+    await Bun.write(envPath, envLines.join("\n") + "\n");
+  }
+  chmodSync(envPath, 384);
+}
+async function ensureEnvInGitignore(cwd) {
+  const gitignorePath = join(cwd, ".gitignore");
+  const file = Bun.file(gitignorePath);
+  if (await file.exists()) {
+    const content = await file.text();
+    const lines = content.split("\n").map((l) => l.trim());
+    const hasEnvEntry = lines.some((line) => line === ".env");
+    if (!hasEnvEntry) {
+      const separator = content.endsWith("\n") ? "" : "\n";
+      await Bun.write(
+        gitignorePath,
+        content + separator + "\n# Environment secrets\n.env\n"
+      );
+    }
+  } else {
+    await Bun.write(gitignorePath, "# Environment secrets\n.env\n");
+  }
+}
+async function verifyVaultConnection(vaultName, port) {
+  const resolvedPort = resolveMuninndbPort(port);
+  const status = await checkMuninndbService(resolvedPort);
+  return status.healthy;
+}
+
+const vaultInitCommand = defineCommand({
+  meta: {
+    name: "vault:init",
+    description: "Set up MuninnDB vault for a project"
+  },
+  args: {
+    "skip-vault": {
+      type: "boolean",
+      description: "Skip MuninnDB vault setup (only create .luca/ directory)",
+      default: false
+    }
+  },
+  async run({ args }) {
+    p.intro("luca vault:init");
+    const cwd = process.cwd();
+    const context = await detectProjectContext();
+    const configPath = join(cwd, ".luca", "config.json");
+    const config = await loadCurrentConfig({ cwd });
+    const existingVault = config.muninn?.vault;
+    if (typeof existingVault === "string" && existingVault.length > 0) {
+      p.log.warn(
+        `Vault already configured (muninn.vault = "${existingVault}").`
+      );
+      p.log.info(
+        "To reconfigure, edit the muninn.vault field in .luca/config.json and run again."
+      );
+      p.outro("Vault setup skipped.");
+      return;
+    }
+    const lucaDir = join(cwd, ".luca");
+    if (!existsSync(lucaDir)) {
+      mkdirSync(lucaDir, { recursive: true });
+      p.log.success("Created .luca/ directory");
+    }
+    if (args["skip-vault"]) {
+      p.log.info("Skipping MuninnDB vault setup (--skip-vault)");
+      p.outro(
+        "Project directory prepared. Run `luca vault:init` later to set up the vault."
+      );
+      return;
+    }
+    const vaultResult = await runVaultWizard(context, cwd);
+    if (!vaultResult) {
+      p.outro("Vault setup cancelled.");
+      return;
+    }
+    const envPath = join(cwd, ".env");
+    await writeVaultConfig(vaultResult.vaultName, configPath);
+    p.log.success("Vault name written to .luca/config.json");
+    await writeApiKeyToEnv(
+      vaultResult.apiKey,
+      envPath,
+      vaultResult.vaultName
+    );
+    p.log.success("API key written to .env");
+    await ensureEnvInGitignore(cwd);
+    p.log.success(".env protected in .gitignore");
+    const reachable = await verifyVaultConnection(vaultResult.vaultName);
+    if (reachable) {
+      p.log.success(
+        `MuninnDB reachable \u2014 vault "${vaultResult.vaultName}" is ready`
+      );
+    } else {
+      p.log.warn(
+        `MuninnDB not reachable. Vault "${vaultResult.vaultName}" will activate when MuninnDB starts.`
+      );
+    }
+    p.outro('Vault configured! Run `lu "<your task>"` to start the pipeline.');
+  }
+});
+
+export { vaultInitCommand };

package/dist/chunks/verification.mjs

@@ -0,0 +1,95 @@
+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 { l as listPhaseSlugs, r as readVerificationResult, a as aggregateVerificationResults } from '../shared/luca.BmhNkYe2.mjs';
+import { l as logger } from '../shared/luca.dM-MKlNE.mjs';
+import 'zod';
+import 'node:os';
+import '../shared/luca.TSMg1t7I.mjs';
+import 'pathe';
+import 'consola';
+
+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 verification: ${r.error}`);
+    process.exit(1);
+  }
+  return r.slug;
+}
+const readCommand = defineCommand({
+  meta: {
+    name: "read",
+    description: "Read a phase's verify.json as JSON (null if no result exists)."
+  },
+  args: {
+    slug: {
+      type: "string",
+      description: "Phase slug to read (default: the active phase)."
+    },
+    "run-id": {
+      type: "string",
+      description: "Current run id. When set, results whose stamped runId does not match are treated as stale and yield null."
+    }
+  },
+  async run({ args }) {
+    const cwd = process.cwd();
+    const slug = await resolveSlug({ explicit: args.slug, cwd });
+    const result = readVerificationResult({
+      cwd,
+      slug,
+      currentRunId: args["run-id"]
+    });
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+  }
+});
+const aggregateCommand = defineCommand({
+  meta: {
+    name: "aggregate",
+    description: "Aggregate every phase's verify.json into milestone-level stats (totalWaves, passCount, failCount, stalledCount, allCriteriaMet, blockingGaps from the latest result)."
+  },
+  args: {
+    "run-id": {
+      type: "string",
+      description: "Current run id; filters out stale per-phase verify.json."
+    }
+  },
+  run({ args }) {
+    const cwd = process.cwd();
+    const results = [];
+    for (const slug of listPhaseSlugs(cwd)) {
+      const result = readVerificationResult({
+        cwd,
+        slug,
+        currentRunId: args["run-id"]
+      });
+      if (result) results.push(result);
+    }
+    process.stdout.write(
+      `${JSON.stringify(aggregateVerificationResults(results), null, 2)}
+`
+    );
+  }
+});
+const verificationCommand = defineCommand({
+  meta: {
+    name: "verification",
+    description: "Read and aggregate Luca workflow verification results."
+  },
+  subCommands: {
+    read: readCommand,
+    aggregate: aggregateCommand
+  }
+});
+
+export { verificationCommand };

package/dist/chunks/version.mjs

@@ -0,0 +1,70 @@
+import { defineCommand } from 'citty';
+import { l as logger } from '../shared/luca.dM-MKlNE.mjs';
+import { LUCA_VERSION } from '../index.mjs';
+import { a as checkPlatform } from '../shared/luca.DTomPq7I.mjs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'pathe';
+import 'consola';
+import 'node:os';
+import '@clack/prompts';
+import 'semver';
+import 'zod';
+
+async function checkForUpdates() {
+  try {
+    const { default: updateNotifier } = await import('update-notifier');
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const possiblePaths = [
+      join(currentDir, "..", "..", "package.json"),
+      // from dist/utils/
+      join(currentDir, "..", "package.json")
+      // from src/utils/
+    ];
+    let pkg = null;
+    for (const pkgPath of possiblePaths) {
+      try {
+        pkg = JSON.parse(await Bun.file(pkgPath).text());
+        break;
+      } catch {
+      }
+    }
+    if (!pkg) {
+      return;
+    }
+    const notifier = updateNotifier({
+      pkg,
+      updateCheckInterval: 1e3 * 60 * 60 * 24
+      // 24 hours
+    });
+    notifier.notify({
+      message: `New Luca CLI version available: {currentVersion} \u2192 {latestVersion}
+Run: bun add -g @alecsibilia/luca@latest`,
+      defer: false
+    });
+  } catch {
+  }
+}
+
+const versionCommand = defineCommand({
+  meta: {
+    name: "version",
+    description: "Show Luca version and platform info"
+  },
+  async run() {
+    const platform = checkPlatform();
+    logger.box(
+      [
+        `Luca CLI v${LUCA_VERSION}`,
+        "",
+        `Platform: ${platform.os} / ${platform.arch}`,
+        `Home:     ${platform.homeDir}`
+      ].join("\n")
+    );
+    try {
+      await checkForUpdates();
+    } catch {
+    }
+  }
+});
+
+export { versionCommand };

package/dist/chunks/workflow.mjs

@@ -0,0 +1,47 @@
+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, s as lucaWorkflowResetTool } 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 resetCommand = defineCommand({
+  meta: {
+    name: "reset",
+    description: "Reset .luca/state.json to schema defaults (idle) and remove the pipeline lock. Destructive but recoverable \u2014 only resets workflow bookkeeping, no source-tree changes. Requires --confirm. Phase-agnostic."
+  },
+  args: {
+    confirm: {
+      type: "boolean",
+      default: false,
+      description: "Must be passed to actually perform the reset. Without it the command refuses so an accidental call cannot wipe the workflow."
+    }
+  },
+  async run({ args }) {
+    await runWriteHandler("workflow reset", lucaWorkflowResetTool, {
+      confirm: args.confirm
+    });
+  }
+});
+const workflowCommand = defineCommand({
+  meta: {
+    name: "workflow",
+    description: "Luca workflow lifecycle operations"
+  },
+  subCommands: {
+    reset: resetCommand
+  }
+});
+
+export { workflowCommand };