@getcoherent/cli 0.6.25 → 0.6.26

package/dist/{chunk-IYLHC4RC.js → chunk-CC3ARMGS.js}

@@ -3,13 +3,234 @@ import {
   getDesignQualityForType,
   inferPageTypeFromRoute
 } from "./chunk-5AHG4NNX.js";
+import {
+  autoFixCode
+} from "./chunk-H644LLXJ.js";
 
 // src/commands/chat/plan-generator.ts
 import { z } from "zod";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { resolve } from "path";
 import chalk from "chalk";
 import { generateSharedComponent } from "@getcoherent/core";
+
+// src/utils/self-heal.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { readdir, readFile } from "fs/promises";
+import { execSync } from "child_process";
+var COHERENT_REQUIRED_PACKAGES = [
+  "lucide-react",
+  "class-variance-authority",
+  "clsx",
+  "tailwind-merge",
+  "@radix-ui/react-slot"
+];
+var IMPORT_FROM_REGEX = /from\s+['"]([^'"]+)['"]/g;
+var NODE_BUILTINS = /* @__PURE__ */ new Set([
+  "assert",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "diagnostics_channel",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "sys",
+  "test",
+  "timers",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "wasi",
+  "worker_threads",
+  "zlib",
+  "fs/promises",
+  "path/posix",
+  "path/win32",
+  "stream/promises",
+  "stream/web",
+  "timers/promises",
+  "util/types"
+]);
+function extractNpmPackagesFromCode(code) {
+  if (typeof code !== "string") return /* @__PURE__ */ new Set();
+  const pkgs = /* @__PURE__ */ new Set();
+  let m;
+  IMPORT_FROM_REGEX.lastIndex = 0;
+  while ((m = IMPORT_FROM_REGEX.exec(code)) !== null) {
+    const spec = m[1];
+    if (spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("@/") || spec === "next") continue;
+    if (spec.startsWith("node:") || NODE_BUILTINS.has(spec)) continue;
+    const pkg = spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0];
+    if (pkg && !NODE_BUILTINS.has(pkg)) pkgs.add(pkg);
+  }
+  return pkgs;
+}
+function getInstalledPackages(projectRoot) {
+  const pkgPath = join(projectRoot, "package.json");
+  if (!existsSync(pkgPath)) return /* @__PURE__ */ new Set();
+  try {
+    const json = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const deps = { ...json.dependencies ?? {}, ...json.devDependencies ?? {} };
+    return new Set(Object.keys(deps));
+  } catch (e) {
+    if (process.env.COHERENT_DEBUG === "1") console.error("Failed to read package.json:", e);
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function collectImportedPackages(dir, extensions) {
+  const packages = /* @__PURE__ */ new Set();
+  if (!existsSync(dir)) return packages;
+  async function walk(d) {
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = join(d, e.name);
+      if (e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules") {
+        await walk(full);
+        continue;
+      }
+      if (!e.isFile()) continue;
+      const ext = e.name.replace(/^.*\./, "");
+      if (!extensions.has(ext)) continue;
+      const content = await readFile(full, "utf-8").catch(() => "");
+      extractNpmPackagesFromCode(content).forEach((p) => packages.add(p));
+    }
+  }
+  await walk(dir);
+  return packages;
+}
+async function findMissingPackages(projectRoot, dirs = ["app", "components"]) {
+  const installed = getInstalledPackages(projectRoot);
+  const required = new Set(COHERENT_REQUIRED_PACKAGES);
+  const imported = /* @__PURE__ */ new Set();
+  const extensions = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx"]);
+  for (const d of dirs) {
+    const abs = join(projectRoot, d);
+    const pkgs = await collectImportedPackages(abs, extensions);
+    pkgs.forEach((p) => imported.add(p));
+  }
+  const needed = /* @__PURE__ */ new Set([...required, ...imported]);
+  return [...needed].filter((p) => !installed.has(p)).sort();
+}
+function findMissingPackagesInCode(code, projectRoot) {
+  const installed = getInstalledPackages(projectRoot);
+  const required = new Set(COHERENT_REQUIRED_PACKAGES);
+  const fromCode = extractNpmPackagesFromCode(code);
+  const needed = /* @__PURE__ */ new Set([...required, ...fromCode]);
+  return [...needed].filter((p) => !installed.has(p)).sort();
+}
+var SAFE_PKG_NAME = /^(@[a-z0-9._-]+\/)?[a-z0-9._-]+$/;
+function installPackages(projectRoot, packages) {
+  if (packages.length === 0) return Promise.resolve(true);
+  const safe = packages.filter((p) => SAFE_PKG_NAME.test(p));
+  if (safe.length === 0) return Promise.resolve(true);
+  return new Promise((resolve2) => {
+    try {
+      const hasPnpm = existsSync(join(projectRoot, "pnpm-lock.yaml"));
+      if (hasPnpm) {
+        execSync(`pnpm add ${safe.join(" ")}`, { cwd: projectRoot, stdio: "pipe" });
+      } else {
+        execSync(`npm install --legacy-peer-deps ${safe.join(" ")}`, {
+          cwd: projectRoot,
+          stdio: "pipe"
+        });
+      }
+      resolve2(true);
+    } catch (e) {
+      if (process.env.COHERENT_DEBUG === "1") console.error("Failed to install packages:", e);
+      resolve2(false);
+    }
+  });
+}
+var CLIENT_HOOKS = /\b(useState|useEffect|useRef|useContext|useReducer|useCallback|useMemo|useId|useTransition|useDeferredValue)\s*\(/;
+var CLIENT_EVENTS = /\b(onClick|onChange|onSubmit|onBlur|onFocus|onKeyDown|onKeyUp|onMouseEnter|onMouseLeave|onScroll|onInput)\s*[={]/;
+function stripMetadataFromCode(code) {
+  const match = code.match(/\bexport\s+const\s+metadata\s*:\s*Metadata\s*=\s*\{/);
+  if (!match) return code;
+  const start = code.indexOf(match[0]);
+  const open = code.indexOf("{", start);
+  if (open === -1) return code;
+  let depth = 1;
+  let i = open + 1;
+  while (i < code.length && depth > 0) {
+    const c = code[i];
+    if (c === "{") depth++;
+    else if (c === "}") depth--;
+    i++;
+  }
+  const end = i;
+  const tail = code.slice(end);
+  const semicolon = tail.match(/^\s*;/);
+  const removeEnd = semicolon ? end + (semicolon.index + semicolon[0].length) : end;
+  return (code.slice(0, start) + code.slice(removeEnd)).replace(/\n{3,}/g, "\n\n").trim();
+}
+function ensureUseClientIfNeeded(code) {
+  const trimmed = code.trimStart();
+  const hasUseClient = trimmed.startsWith("'use client'") || trimmed.startsWith('"use client"');
+  const needsUseClient = CLIENT_HOOKS.test(code) || CLIENT_EVENTS.test(code);
+  let out = code;
+  if (hasUseClient || needsUseClient) {
+    out = stripMetadataFromCode(out);
+    if (needsUseClient && !hasUseClient) out = `'use client'
+
+${out}`;
+  }
+  return out;
+}
+function sanitizeMetadataStrings(code) {
+  let out = code.replace(/\\'(\s*[}\],])/g, "'$1");
+  out = out.replace(/(:\s*'.+)\\'(\s*)$/gm, "$1'$2");
+  for (const key of ["description", "title"]) {
+    const re = new RegExp(`\\b${key}:\\s*'((?:[^'\\\\]|'(?![,}]))*)'`, "gs");
+    out = out.replace(re, (_, inner) => `${key}: '${inner.replace(/'/g, "\\'")}'`);
+  }
+  return out;
+}
+function fixEscapedClosingQuotes(code) {
+  let out = code.replace(/\\'(\s*[}\],])/g, "'$1");
+  out = out.replace(/(:\s*'.+)\\'(\s*)$/gm, "$1'$2");
+  return out;
+}
+function fixUnescapedLtInJsx(code) {
+  let out = code;
+  out = out.replace(/>([^<\n]*)<(\d)/g, ">$1&lt;$2");
+  out = out.replace(/>([^<\n]*)<([^/a-zA-Z!{>\n])/g, ">$1&lt;$2");
+  return out;
+}
+
+// src/commands/chat/plan-generator.ts
 var LAYOUT_SYNONYMS = {
   horizontal: "header",
   top: "header",
@@ -222,9 +443,9 @@ function savePlan(projectRoot, plan) {
 function loadPlan(projectRoot) {
   const planPath = resolve(projectRoot, ".coherent", "plan.json");
   if (cachedPlan?.path === planPath) return cachedPlan.plan;
-  if (!existsSync(planPath)) return null;
+  if (!existsSync2(planPath)) return null;
   try {
-    const raw = JSON.parse(readFileSync(planPath, "utf-8"));
+    const raw = JSON.parse(readFileSync2(planPath, "utf-8"));
     const parsed = ArchitecturePlanSchema.safeParse(raw);
     if (!parsed.success) return null;
     cachedPlan = { path: planPath, plan: parsed.data };
@@ -320,12 +541,15 @@ Return JSON with { requests: [{ type: "add-page", changes: { name: "ComponentNam
   }
   for (const comp of results) {
     const planned = plan.sharedComponents.find((c) => c.name === comp.name);
-    const propsInterface = extractPropsInterface(comp.code, comp.name);
-    const usageExample = extractUsageExample(comp.code, comp.name);
+    const { code: fixedCode } = await autoFixCode(comp.code);
+    const missing = findMissingPackagesInCode(fixedCode, projectRoot);
+    if (missing.length > 0) await installPackages(projectRoot, missing);
+    const propsInterface = extractPropsInterface(fixedCode, comp.name);
+    const usageExample = extractUsageExample(fixedCode, comp.name);
     await generateSharedComponent(projectRoot, {
       name: comp.name,
       type: planned?.type ?? "section",
-      code: comp.code,
+      code: fixedCode,
       description: planned?.description,
       usedIn: planned?.usedBy ?? [],
       source: "generated",
@@ -338,6 +562,16 @@ Return JSON with { requests: [{ type: "add-page", changes: { name: "ComponentNam
 }
 
 export {
+  COHERENT_REQUIRED_PACKAGES,
+  extractNpmPackagesFromCode,
+  getInstalledPackages,
+  findMissingPackages,
+  findMissingPackagesInCode,
+  installPackages,
+  ensureUseClientIfNeeded,
+  sanitizeMetadataStrings,
+  fixEscapedClosingQuotes,
+  fixUnescapedLtInJsx,
   RouteGroupSchema,
   PlannedComponentSchema,
   PageNoteSchema,