@alecsibilia/luca 13.0.0-alpha.1

package/dist/shared/luca.B3saVjJm.mjs

@@ -0,0 +1,163 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { mkdir, readdir, copyFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function defaultClaudeHome() {
+  return join(homedir(), ".claude");
+}
+async function installSkills(opts) {
+  const log = opts.log ?? (() => {
+  });
+  const claudeHome = opts.claudeHome ?? defaultClaudeHome();
+  const resolved = resolveBundledArtifacts({
+    claudeArtifactsRoot: opts.claudeArtifactsRoot,
+    skillsRoot: opts.skillsRoot
+  });
+  if (resolved === null) {
+    log(
+      "  skip:  bundled artifacts not found \u2014 could not locate the @alecsibilia/luca package root (running from a non-bundled dev tree?)"
+    );
+    return;
+  }
+  const { claudeArtifactsRoot, skillsRoot } = resolved;
+  if (!existsSync(claudeArtifactsRoot)) {
+    log(
+      `  skip:  bundled artifacts not found at ${claudeArtifactsRoot} (running from a non-bundled dev tree? did the umbrella build run?)`
+    );
+    return;
+  }
+  await copyDir({
+    from: join(claudeArtifactsRoot, "commands"),
+    to: join(claudeHome, "commands"),
+    log,
+    label: "command"
+  });
+  await copyDir({
+    from: join(claudeArtifactsRoot, "agents"),
+    to: join(claudeHome, "agents"),
+    log,
+    label: "agent"
+  });
+  await copySkillTree({
+    from: skillsRoot,
+    to: join(claudeHome, "skills"),
+    log
+  });
+}
+async function listBundledArtifacts(opts = {}) {
+  const resolved = resolveBundledArtifacts({
+    claudeArtifactsRoot: opts.claudeArtifactsRoot,
+    skillsRoot: opts.skillsRoot
+  });
+  if (resolved === null) return null;
+  const { claudeArtifactsRoot, skillsRoot } = resolved;
+  if (!existsSync(claudeArtifactsRoot)) return null;
+  return {
+    commands: await listEntries(
+      join(claudeArtifactsRoot, "commands"),
+      "file",
+      ".md"
+    ),
+    agents: await listEntries(
+      join(claudeArtifactsRoot, "agents"),
+      "file",
+      ".md"
+    ),
+    skills: await listEntries(skillsRoot, "dir")
+  };
+}
+function resolveBundledArtifacts(overrides) {
+  if (overrides.claudeArtifactsRoot !== void 0 && overrides.skillsRoot !== void 0) {
+    return {
+      claudeArtifactsRoot: overrides.claudeArtifactsRoot,
+      skillsRoot: overrides.skillsRoot
+    };
+  }
+  const distClaude = findUmbrellaDistClaude();
+  if (distClaude === null) return null;
+  return {
+    claudeArtifactsRoot: overrides.claudeArtifactsRoot ?? join(distClaude, ".claude"),
+    skillsRoot: overrides.skillsRoot ?? join(distClaude, "skills")
+  };
+}
+function findUmbrellaDistClaude() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 20; i += 1) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "@alecsibilia/luca") {
+          return join(dir, "dist", "claude");
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 20; i += 1) {
+    const candidate = join(dir, "packages", "luca", "package.json");
+    if (existsSync(candidate)) {
+      try {
+        const pkg = JSON.parse(readFileSync(candidate, "utf-8"));
+        if (pkg.name === "@alecsibilia/luca") {
+          return join(dir, "packages", "luca", "dist", "claude");
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function resolveBundledArtifactsForHooks() {
+  const distClaude = findUmbrellaDistClaude();
+  if (distClaude === null) return null;
+  return join(distClaude, ".claude");
+}
+async function listEntries(dir, kind, ext) {
+  if (!existsSync(dir)) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  return entries.filter((e) => kind === "file" ? e.isFile() : e.isDirectory()).filter((e) => ext ? e.name.endsWith(ext) : true).map((e) => e.name);
+}
+async function copySkillTree(args) {
+  if (!existsSync(args.from)) {
+    args.log(`  skip:  skills source missing (${args.from})`);
+    return;
+  }
+  const entries = await readdir(args.from, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillFrom = join(args.from, entry.name);
+    const skillTo = join(args.to, entry.name);
+    await mkdir(skillTo, { recursive: true });
+    const files = await readdir(skillFrom, { withFileTypes: true });
+    for (const file of files) {
+      if (!file.isFile()) continue;
+      await copyFile(join(skillFrom, file.name), join(skillTo, file.name));
+      args.log(`  write: ${join(skillTo, file.name)}`);
+    }
+  }
+}
+async function copyDir(args) {
+  if (!existsSync(args.from)) {
+    args.log(`  skip:  ${args.label}s source missing (${args.from})`);
+    return;
+  }
+  await mkdir(args.to, { recursive: true });
+  const entries = await readdir(args.from, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    await copyFile(join(args.from, entry.name), join(args.to, entry.name));
+    args.log(`  write: ${join(args.to, entry.name)}`);
+  }
+}
+
+export { defaultClaudeHome as d, installSkills as i, listBundledArtifacts as l, resolveBundledArtifactsForHooks as r };

package/dist/shared/luca.BYdjkfnz.mjs

@@ -0,0 +1,217 @@
+import { join } from 'pathe';
+import { existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { z } from 'zod';
+import { a as checkPlatform } from './luca.DTomPq7I.mjs';
+
+const LucaHomePathsSchema = z.object({
+  /** Absolute path to the root ~/.luca/ directory. */
+  root: z.string(),
+  /** Absolute path to the ~/.luca/bin/ directory for executables. */
+  bin: z.string()
+});
+function getLucaHomePaths() {
+  const home = homedir();
+  const root = join(home, ".luca");
+  const paths = {
+    root,
+    bin: join(root, "bin")
+  };
+  return LucaHomePathsSchema.parse(paths);
+}
+async function ensureLucaHome() {
+  const paths = getLucaHomePaths();
+  const dirs = [paths.root, paths.bin];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+  }
+  return paths;
+}
+
+const SUPPORTED_PLATFORM_TARGETS = [
+  "darwin-arm64",
+  "darwin-x64",
+  "linux-x64",
+  "linux-arm64"
+];
+z.enum(SUPPORTED_PLATFORM_TARGETS);
+const MuninndbBinaryStatusSchema = z.object({
+  /** Whether the MuninnDB binary file exists on disk. */
+  installed: z.boolean(),
+  /** Absolute path to the binary, or null if not found. */
+  path: z.string().nullable(),
+  /** Version string reported by the binary, or null if unknown. */
+  version: z.string().nullable(),
+  /** Whether the binary has executable permissions. */
+  executable: z.boolean()
+});
+const MuninndbServiceStatusSchema = z.object({
+  /** Whether the MuninnDB process appears to be running. */
+  running: z.boolean(),
+  /** Port number the service listens on. */
+  port: z.number(),
+  /** Process ID from the pidfile, or null if unavailable. */
+  pid: z.number().nullable(),
+  /** Whether the service responds to HTTP health checks. */
+  healthy: z.boolean()
+});
+const MuninndbInstallResultSchema = z.object({
+  /** Whether the download and installation succeeded. */
+  success: z.boolean(),
+  /** Absolute path to the installed binary, or null on failure. */
+  binaryPath: z.string().nullable(),
+  /** Error message describing the failure, or null on success. */
+  error: z.string().nullable()
+});
+const PLATFORM_TARGET_MAP = {
+  "darwin-arm64": "darwin-arm64",
+  "darwin-x64": "darwin-x64",
+  "linux-x64": "linux-x64",
+  "linux-arm64": "linux-arm64"
+};
+function resolvePlatformTarget() {
+  const platform = checkPlatform();
+  const key = `${platform.os}-${platform.arch}`;
+  const target = PLATFORM_TARGET_MAP[key];
+  if (!target) {
+    return {
+      success: false,
+      error: `Unsupported platform: ${platform.os}/${platform.arch}. MuninnDB supports: ${SUPPORTED_PLATFORM_TARGETS.join(", ")}`
+    };
+  }
+  return { success: true, target };
+}
+const MUNINNDB_DEFAULT_PORT = 8476;
+const MUNINNDB_BINARY_NAME = "muninn";
+function getCommonBinaryPaths() {
+  const home = process.env.HOME;
+  return [
+    ...home ? [
+      join(home, ".local", "bin", MUNINNDB_BINARY_NAME),
+      join(home, "bin", MUNINNDB_BINARY_NAME),
+      join(home, ".muninndb", "bin", MUNINNDB_BINARY_NAME),
+      join(home, ".muninndb", MUNINNDB_BINARY_NAME),
+      join(home, ".muninn", "bin", MUNINNDB_BINARY_NAME),
+      join(home, ".cargo", "bin", MUNINNDB_BINARY_NAME)
+    ] : [],
+    join("/usr", "local", "bin", MUNINNDB_BINARY_NAME)
+  ];
+}
+function resolveMuninndbPort(port) {
+  if (port !== void 0) return port;
+  if (process.env.MUNINNDB_PORT) {
+    const parsed = parseInt(process.env.MUNINNDB_PORT, 10);
+    if (!isNaN(parsed)) return parsed;
+  }
+  return MUNINNDB_DEFAULT_PORT;
+}
+
+async function checkMuninndbBinary(binaryPath) {
+  const preferredPath = join(getLucaHomePaths().bin, MUNINNDB_BINARY_NAME);
+  let resolvedPath = preferredPath;
+  const exists = await Bun.file(resolvedPath).exists();
+  if (!exists) {
+    const candidates = getCommonBinaryPaths();
+    let found = false;
+    for (const candidate of candidates) {
+      if (await Bun.file(candidate).exists()) {
+        resolvedPath = candidate;
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      const whichResult = Bun.which(MUNINNDB_BINARY_NAME);
+      if (whichResult && await Bun.file(whichResult).exists()) {
+        resolvedPath = whichResult;
+        found = true;
+      }
+    }
+    if (!found) {
+      return MuninndbBinaryStatusSchema.parse({
+        installed: false,
+        path: null,
+        version: null,
+        executable: false
+      });
+    }
+  }
+  let executable = false;
+  try {
+    const result = await Bun.$`test -x ${resolvedPath}`.quiet().nothrow();
+    executable = result.exitCode === 0;
+  } catch {
+    executable = false;
+  }
+  let version = null;
+  try {
+    const result = await Bun.$`${resolvedPath} --version`.quiet().nothrow();
+    if (result.exitCode === 0) {
+      version = result.stdout.toString().trim() || null;
+    }
+  } catch {
+  }
+  return MuninndbBinaryStatusSchema.parse({
+    installed: true,
+    path: resolvedPath,
+    version,
+    executable
+  });
+}
+async function checkMuninndbService(port) {
+  const resolvedPort = resolveMuninndbPort(port);
+  let pid = null;
+  try {
+    const pidfilePath = join(getLucaHomePaths().root, "muninndb.pid");
+    const pidfileExists = await Bun.file(pidfilePath).exists();
+    if (pidfileExists) {
+      const pidStr = await Bun.file(pidfilePath).text();
+      const parsed = parseInt(pidStr.trim(), 10);
+      if (!isNaN(parsed) && parsed > 0) {
+        pid = parsed;
+      }
+    }
+  } catch {
+  }
+  let healthy = false;
+  let running = false;
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    const response = await fetch(
+      `http://localhost:${resolvedPort}/health`,
+      {
+        signal: controller.signal
+      }
+    );
+    clearTimeout(timeout);
+    healthy = response.ok;
+    running = true;
+  } catch {
+    healthy = false;
+    running = false;
+  }
+  return MuninndbServiceStatusSchema.parse({
+    running,
+    port: resolvedPort,
+    pid,
+    healthy
+  });
+}
+async function waitForMuninndbHealthy(options = {}) {
+  const { port, timeoutMs = 1e4, intervalMs = 500 } = options;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const status = await checkMuninndbService(port);
+    if (status.healthy) {
+      return status;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  return checkMuninndbService(port);
+}
+
+export { MuninndbInstallResultSchema as M, MUNINNDB_BINARY_NAME as a, getCommonBinaryPaths as b, resolveMuninndbPort as c, checkMuninndbService as d, MuninndbServiceStatusSchema as e, ensureLucaHome as f, getLucaHomePaths as g, checkMuninndbBinary as h, MUNINNDB_DEFAULT_PORT as i, resolvePlatformTarget as r, waitForMuninndbHealthy as w };

package/dist/shared/luca.BmhNkYe2.mjs

@@ -0,0 +1,56 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { u as VerificationResultSchema, v as PHASE_SLUG_RE } from './luca.CRmaAfXR.mjs';
+import { p as phasePathFor } from './luca.TSMg1t7I.mjs';
+import { join as join$1 } from 'pathe';
+import 'node:fs/promises';
+import 'node:crypto';
+import 'node:module';
+import 'node:url';
+import 'node:child_process';
+
+function readVerificationResult(opts) {
+  const p = join(opts.cwd, phasePathFor(opts.slug, "verify"));
+  if (!existsSync(p)) return null;
+  try {
+    const parsed = VerificationResultSchema.safeParse(
+      JSON.parse(readFileSync(p, "utf-8"))
+    );
+    if (!parsed.success) return null;
+    const result = parsed.data;
+    if (opts.currentRunId && typeof result.runId === "string" && result.runId.length > 0 && result.runId !== opts.currentRunId) {
+      return null;
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function aggregateVerificationResults(results) {
+  const latest = results[results.length - 1];
+  const blockingGaps = latest ? latest.criteria.filter((c) => !c.met && c.blocking).map((c) => ({
+    criterionId: c.criterionId,
+    gap: c.gap ?? "Unknown",
+    wave: latest.wave
+  })) : [];
+  return {
+    totalWaves: results.length,
+    passCount: results.filter((r) => r.status === "PASS").length,
+    failCount: results.filter((r) => r.status === "FAIL").length,
+    stalledCount: results.filter((r) => r.status === "STALLED").length,
+    allCriteriaMet: latest ? latest.criteria.filter((c) => c.blocking).every((c) => c.met) : false,
+    blockingGaps
+  };
+}
+
+function listPhaseSlugs(cwd) {
+  const phasesDir = join$1(cwd, ".luca", "phases");
+  if (!existsSync(phasesDir)) return [];
+  try {
+    return readdirSync(phasesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && PHASE_SLUG_RE.test(e.name)).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+
+export { aggregateVerificationResults as a, listPhaseSlugs as l, readVerificationResult as r };