@alecsibilia/luca 13.0.0-alpha.1

package/dist/chunks/claim-verify.mjs

@@ -0,0 +1,465 @@
+import { defineCommand } from 'citty';
+import { resolve } from 'pathe';
+import '../shared/luca.CRmaAfXR.mjs';
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import 'node:fs/promises';
+import { join } from 'node:path';
+import 'node:crypto';
+import 'node:module';
+import 'node:url';
+import { spawnSync } from 'node:child_process';
+import { l as logger } from '../shared/luca.dM-MKlNE.mjs';
+import 'zod';
+import 'node:os';
+import 'consola';
+
+const SYMBOL_STOPWORDS = /* @__PURE__ */ new Set([
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "void",
+  "any",
+  "unknown",
+  "never",
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "array",
+  "bun",
+  "npm",
+  "pnpm",
+  "yarn",
+  "git",
+  "gh",
+  "pr",
+  "ci",
+  "cd",
+  "repo",
+  "main",
+  "master",
+  "dev",
+  "build",
+  "test",
+  "lint",
+  "tsc",
+  "eslint",
+  "todo",
+  "fixme",
+  "note",
+  "warn",
+  "info",
+  "log",
+  "http",
+  "https",
+  "json",
+  "yaml",
+  "toml",
+  "env",
+  "src",
+  "dist",
+  "lib",
+  "app",
+  "apps"
+]);
+const COUNTABLE_NOUNS = /* @__PURE__ */ new Set([
+  "file",
+  "files",
+  "test",
+  "tests",
+  "table",
+  "tables",
+  "index",
+  "indexes",
+  "indices",
+  "function",
+  "functions",
+  "endpoint",
+  "endpoints",
+  "route",
+  "routes",
+  "mutation",
+  "mutations",
+  "query",
+  "queries",
+  "action",
+  "actions",
+  "tool",
+  "tools",
+  "mode",
+  "modes",
+  "phase",
+  "phases",
+  "wave",
+  "waves",
+  "commit",
+  "commits",
+  "package",
+  "packages",
+  "module",
+  "modules",
+  "class",
+  "classes",
+  "method",
+  "methods",
+  "component",
+  "components",
+  "hook",
+  "hooks"
+]);
+function singularize(noun) {
+  const lower = noun.toLowerCase();
+  if (lower === "indices") return "index";
+  if (lower === "queries") return "query";
+  if (lower === "classes") return "class";
+  if (lower === "indexes") return "index";
+  if (lower.endsWith("ies") && lower.length > 3) {
+    return `${lower.slice(0, -3)}y`;
+  }
+  if (lower.endsWith("s") && !lower.endsWith("ss")) return lower.slice(0, -1);
+  return lower;
+}
+const BACKTICK_RE = /`([^`\n]+)`/g;
+const FILE_PATH_RE = /(?:^|[\s(`'"])((?:packages|src|apps|lib|tests?|docs?|\.planning|\.luca|\.changeset|\.github)\/[\w./-]+\.[\w]+)(?=[\s)`'".,;!?]|$)/g;
+const QUANTITATIVE_RE = /\b(\d+)\s+([a-zA-Z]+)\b/g;
+const IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function extractClaims(text) {
+  if (!text) return [];
+  const lines = text.split("\n");
+  const seen = /* @__PURE__ */ new Set();
+  const claims = [];
+  const pushIfNew = (key, claim) => {
+    if (seen.has(key)) return;
+    seen.add(key);
+    claims.push(claim);
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const sourceLine = i + 1;
+    const sourceContext = line.trim().slice(0, 240);
+    for (const match of line.matchAll(BACKTICK_RE)) {
+      const inner = (match[1] ?? "").trim();
+      if (inner.includes("/") && /\.\w+(?:[#?:]|$)/.test(inner)) continue;
+      if (!IDENTIFIER_RE.test(inner)) continue;
+      if (inner.length < 3) continue;
+      if (SYMBOL_STOPWORDS.has(inner.toLowerCase())) continue;
+      pushIfNew(`symbol:${inner}`, {
+        type: "symbol",
+        text: match[0],
+        identifier: inner,
+        sourceLine,
+        sourceContext
+      });
+    }
+    for (const match of line.matchAll(FILE_PATH_RE)) {
+      const path = match[1];
+      if (!path) continue;
+      pushIfNew(`path:${path}`, {
+        type: "file-path",
+        text: path,
+        path,
+        sourceLine,
+        sourceContext
+      });
+    }
+    for (const match of line.matchAll(QUANTITATIVE_RE)) {
+      const numStr = match[1];
+      const noun = match[2];
+      if (!numStr || !noun) continue;
+      if (numStr.length === 4) {
+        const n = Number(numStr);
+        if (n >= 1900 && n <= 2200) continue;
+      }
+      const lowerNoun = noun.toLowerCase();
+      if (!COUNTABLE_NOUNS.has(lowerNoun)) continue;
+      const num = Number(numStr);
+      if (!Number.isFinite(num)) continue;
+      pushIfNew(`count:${num}:${lowerNoun}`, {
+        type: "quantitative",
+        text: `${numStr} ${noun}`,
+        number: num,
+        noun: singularize(lowerNoun),
+        sourceLine,
+        sourceContext
+      });
+    }
+  }
+  return claims;
+}
+function gitAvailable(repoRoot) {
+  const r = spawnSync(
+    "git",
+    ["-C", repoRoot, "rev-parse", "--is-inside-work-tree"],
+    { encoding: "utf-8" }
+  );
+  return r.status === 0;
+}
+function gitGrepFiles(repoRoot, needle, timeoutMs) {
+  const r = spawnSync(
+    "git",
+    ["-C", repoRoot, "grep", "--untracked", "-l", "--fixed-strings", needle],
+    { encoding: "utf-8", timeout: timeoutMs }
+  );
+  if (r.signal === "SIGTERM" || r.error?.message?.includes("ETIMEDOUT")) {
+    return { ok: false, matchedFiles: [], timedOut: true };
+  }
+  if (r.status === 1) return { ok: true, matchedFiles: [], timedOut: false };
+  if (r.status !== 0) return { ok: false, matchedFiles: [], timedOut: false };
+  const matchedFiles = (r.stdout ?? "").split("\n").map((s) => s.trim()).filter(Boolean);
+  return { ok: true, matchedFiles, timedOut: false };
+}
+const FS_SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  "coverage",
+  ".cache"
+]);
+const FS_SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".lock",
+  ".lockb"
+]);
+const FS_MAX_FILE_BYTES = 5 * 1024 * 1024;
+function fsGrepFiles(repoRoot, needle, timeoutMs) {
+  const start = Date.now();
+  const matchedFiles = [];
+  const stack = [repoRoot];
+  while (stack.length > 0) {
+    if (Date.now() - start > timeoutMs) {
+      return { ok: false, matchedFiles, timedOut: true };
+    }
+    const dir = stack.pop();
+    if (dir === void 0) break;
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      const full = join(dir, name);
+      let info;
+      try {
+        info = statSync(full);
+      } catch {
+        continue;
+      }
+      if (info.isDirectory()) {
+        if (FS_SKIP_DIRS.has(name)) continue;
+        stack.push(full);
+        continue;
+      }
+      if (!info.isFile()) continue;
+      const dotIdx = name.lastIndexOf(".");
+      if (dotIdx >= 0) {
+        const ext = name.slice(dotIdx).toLowerCase();
+        if (FS_SKIP_EXTENSIONS.has(ext)) continue;
+      }
+      if (info.size > FS_MAX_FILE_BYTES) continue;
+      try {
+        if (readFileSync(full).includes(needle)) {
+          matchedFiles.push(full);
+        }
+      } catch {
+      }
+    }
+  }
+  return { ok: true, matchedFiles, timedOut: false };
+}
+function searchFiles(repoRoot, needle, timeoutMs, useGit) {
+  return useGit ? gitGrepFiles(repoRoot, needle, timeoutMs) : fsGrepFiles(repoRoot, needle, timeoutMs);
+}
+function verifyClaims(claims, opts) {
+  const totalBudgetMs = opts.totalBudgetMs ?? 3e4;
+  const perClaimBudgetMs = opts.perClaimBudgetMs ?? 5e3;
+  const useGit = gitAvailable(opts.repoRoot);
+  const start = Date.now();
+  const failures = [];
+  let timedOut = false;
+  const breakdown = { symbols: 0, filePaths: 0, quantitative: 0 };
+  for (const claim of claims) {
+    if (claim.type === "symbol") breakdown.symbols++;
+    else if (claim.type === "file-path") breakdown.filePaths++;
+    else breakdown.quantitative++;
+    if (Date.now() - start > totalBudgetMs) {
+      timedOut = true;
+      failures.push({
+        claim,
+        reason: "timeout",
+        evidence: `Total budget ${totalBudgetMs}ms exhausted before this claim was checked.`
+      });
+      continue;
+    }
+    if (claim.type === "symbol" && claim.identifier) {
+      const r = searchFiles(
+        opts.repoRoot,
+        claim.identifier,
+        perClaimBudgetMs,
+        useGit
+      );
+      if (r.timedOut) {
+        timedOut = true;
+        failures.push({
+          claim,
+          reason: "timeout",
+          evidence: `Search for symbol "${claim.identifier}" exceeded ${perClaimBudgetMs}ms.`
+        });
+        continue;
+      }
+      if (!r.ok || r.matchedFiles.length === 0) {
+        failures.push({
+          claim,
+          reason: "symbol-not-found",
+          evidence: `git grep for "${claim.identifier}" returned 0 hits.`
+        });
+      }
+      continue;
+    }
+    if (claim.type === "file-path" && claim.path) {
+      const abs = join(opts.repoRoot, claim.path);
+      if (!existsSync(abs)) {
+        failures.push({
+          claim,
+          reason: "file-not-found",
+          evidence: `Path "${claim.path}" does not exist (resolved to ${abs}).`
+        });
+      }
+      continue;
+    }
+    if (claim.type === "quantitative" && claim.noun && typeof claim.number === "number") {
+      const r = searchFiles(
+        opts.repoRoot,
+        claim.noun,
+        perClaimBudgetMs,
+        useGit
+      );
+      if (r.timedOut) {
+        timedOut = true;
+        failures.push({
+          claim,
+          reason: "timeout",
+          evidence: `Search for noun "${claim.noun}" exceeded ${perClaimBudgetMs}ms.`
+        });
+        continue;
+      }
+      if (!r.ok) {
+        failures.push({
+          claim,
+          reason: "count-mismatch",
+          evidence: `grep for "${claim.noun}" failed; cannot verify "${claim.text}".`
+        });
+        continue;
+      }
+      const found = r.matchedFiles.length;
+      if (Math.abs(found - claim.number) > 1) {
+        failures.push({
+          claim,
+          reason: "count-mismatch",
+          evidence: `Claim says "${claim.text}", repo has ${found} file(s) mentioning "${claim.noun}" (tolerance \xB11).`
+        });
+      }
+      continue;
+    }
+  }
+  return {
+    passed: failures.length === 0,
+    totalClaims: claims.length,
+    failures,
+    extractedBreakdown: breakdown,
+    timedOut
+  };
+}
+function verifyTextArtifact(text, opts) {
+  return verifyClaims(extractClaims(text), opts);
+}
+function verifyFile(filePath, opts) {
+  let text;
+  try {
+    text = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      passed: false,
+      totalClaims: 0,
+      failures: [
+        {
+          claim: {
+            type: "file-path",
+            text: filePath,
+            path: filePath,
+            sourceLine: 0,
+            sourceContext: ""
+          },
+          reason: "artifact-unreadable",
+          evidence: `Could not read "${filePath}": ${msg}`
+        }
+      ],
+      extractedBreakdown: { symbols: 0, filePaths: 0, quantitative: 0 },
+      timedOut: false
+    };
+  }
+  return verifyTextArtifact(text, opts);
+}
+
+const claimVerifyCommand = defineCommand({
+  meta: {
+    name: "claim-verify",
+    description: "Verify that a text artifact cites symbols, file paths and counts that exist in the working tree."
+  },
+  args: {
+    file: {
+      type: "positional",
+      required: true,
+      description: "Path to the text artifact to verify (changeset, PR body, plan)."
+    },
+    "repo-root": {
+      type: "string",
+      description: "Repo root that claims are resolved against (default: cwd)."
+    }
+  },
+  run({ args }) {
+    const repoRoot = args["repo-root"] ? resolve(args["repo-root"]) : process.cwd();
+    const report = verifyFile(resolve(args.file), { repoRoot });
+    const b = report.extractedBreakdown;
+    logger.info(
+      `Verified ${report.totalClaims} claim(s): ${b.symbols} symbol, ${b.filePaths} path, ${b.quantitative} quantitative.`
+    );
+    if (report.timedOut) {
+      logger.warn(
+        "Time budget exhausted \u2014 some claims were not verified."
+      );
+    }
+    for (const failure of report.failures) {
+      const loc = failure.claim.sourceLine > 0 ? ` (line ${failure.claim.sourceLine})` : "";
+      logger.error(
+        `${failure.reason}: ${failure.claim.text}${loc}
+  ${failure.evidence}`
+      );
+    }
+    if (report.passed) {
+      logger.success("All claims verified.");
+      process.exitCode = 0;
+    } else {
+      logger.error(
+        `${report.failures.length} claim(s) failed verification.`
+      );
+      process.exitCode = 1;
+    }
+  }
+});
+
+export { claimVerifyCommand };

package/dist/chunks/classify.mjs

@@ -0,0 +1,105 @@
+import { defineCommand } from 'citty';
+import { C as ClassifyComplexityInputSchema } from '../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 { l as logger } from '../shared/luca.dM-MKlNE.mjs';
+import 'zod';
+import 'node:os';
+import 'consola';
+
+function classifyComplexity(input) {
+  const {
+    taskDescription,
+    estimatedFileCount,
+    crossCuttingConcerns,
+    hasBreakingChanges,
+    affectedDomains
+  } = ClassifyComplexityInputSchema.parse(input);
+  let score = 0;
+  if (estimatedFileCount <= 2) score += 0;
+  else if (estimatedFileCount <= 5) score += 1;
+  else if (estimatedFileCount <= 15) score += 2;
+  else if (estimatedFileCount <= 30) score += 3;
+  else score += 4;
+  score += Math.min(crossCuttingConcerns.length, 4);
+  if (hasBreakingChanges) score += 2;
+  if (affectedDomains.length > 3) score += 2;
+  else if (affectedDomains.length > 1) score += 1;
+  const desc = taskDescription.toLowerCase();
+  if (desc.includes("refactor") || desc.includes("migration")) score += 1;
+  if (desc.includes("security") || desc.includes("auth")) score += 1;
+  if (desc.includes("database") || desc.includes("schema")) score += 1;
+  const complexity = score <= 1 ? "TRIVIAL" : score <= 3 ? "SIMPLE" : score <= 6 ? "MODERATE" : score <= 9 ? "COMPLEX" : "CRITICAL";
+  const fileScope = estimatedFileCount <= 3 ? "small" : estimatedFileCount <= 15 ? "medium" : "large";
+  const dependencyDepth = crossCuttingConcerns.length <= 1 ? "shallow" : crossCuttingConcerns.length <= 3 ? "moderate" : "deep";
+  const riskLevel = hasBreakingChanges || score > 6 ? "high" : score > 3 ? "medium" : "low";
+  return {
+    complexity,
+    reasoning: `Score ${score}: ${estimatedFileCount} files, ${crossCuttingConcerns.length} cross-cutting concerns, ${affectedDomains.length} domains${hasBreakingChanges ? ", has breaking changes" : ""}`,
+    factors: { fileScope, dependencyDepth, riskLevel }
+  };
+}
+
+function splitList(value) {
+  if (!value) return [];
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+const classifyCommand = defineCommand({
+  meta: {
+    name: "classify",
+    description: "Classify a development task\u2019s complexity (TRIVIAL \u2192 CRITICAL)."
+  },
+  args: {
+    task: {
+      type: "string",
+      required: true,
+      description: "Task description."
+    },
+    files: {
+      type: "string",
+      description: "Estimated number of files affected."
+    },
+    concerns: {
+      type: "string",
+      description: "Comma-separated cross-cutting concerns."
+    },
+    domains: {
+      type: "string",
+      description: "Comma-separated affected architectural domains."
+    },
+    breaking: {
+      type: "boolean",
+      description: "The task introduces breaking changes."
+    },
+    json: {
+      type: "boolean",
+      description: "Emit the full ComplexityResult as JSON."
+    }
+  },
+  run({ args }) {
+    const result = classifyComplexity({
+      taskDescription: args.task,
+      estimatedFileCount: args.files !== void 0 ? Number(args.files) : void 0,
+      crossCuttingConcerns: splitList(args.concerns),
+      hasBreakingChanges: args.breaking,
+      affectedDomains: splitList(args.domains)
+    });
+    if (args.json) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+      return;
+    }
+    logger.info(`Complexity: ${result.complexity}`);
+    logger.info(result.reasoning);
+    logger.info(
+      `Factors: fileScope=${result.factors.fileScope}, dependencyDepth=${result.factors.dependencyDepth}, riskLevel=${result.factors.riskLevel}`
+    );
+  }
+});
+
+export { classifyCommand };