@getcoherent/cli 0.6.12 → 0.6.14

package/dist/chunk-WRDWFCQJ.js

@@ -0,0 +1,323 @@
+import {
+  CORE_CONSTRAINTS,
+  getDesignQualityForType,
+  inferPageTypeFromRoute
+} from "./chunk-5AHG4NNX.js";
+
+// src/commands/chat/plan-generator.ts
+import { z } from "zod";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import chalk from "chalk";
+import { generateSharedComponent } from "@getcoherent/core";
+var LAYOUT_SYNONYMS = {
+  horizontal: "header",
+  top: "header",
+  nav: "header",
+  navbar: "header",
+  topbar: "header",
+  "top-bar": "header",
+  vertical: "sidebar",
+  left: "sidebar",
+  side: "sidebar",
+  drawer: "sidebar",
+  full: "both",
+  combined: "both",
+  empty: "none",
+  minimal: "none",
+  clean: "none"
+};
+var PAGE_TYPE_SYNONYMS = {
+  landing: "marketing",
+  public: "marketing",
+  home: "marketing",
+  website: "marketing",
+  static: "marketing",
+  application: "app",
+  dashboard: "app",
+  admin: "app",
+  panel: "app",
+  console: "app",
+  authentication: "auth",
+  login: "auth",
+  "log-in": "auth",
+  register: "auth",
+  signin: "auth",
+  "sign-in": "auth",
+  signup: "auth",
+  "sign-up": "auth"
+};
+var COMPONENT_TYPE_SYNONYMS = {
+  component: "widget",
+  ui: "widget",
+  element: "widget",
+  block: "widget",
+  "page-section": "section",
+  hero: "section",
+  feature: "section",
+  area: "section",
+  nav: "navigation",
+  navbar: "navigation",
+  sidebar: "navigation",
+  menu: "navigation",
+  "data display": "data-display",
+  table: "data-display",
+  chart: "data-display",
+  card: "data-display",
+  stats: "data-display",
+  input: "form",
+  filter: "form",
+  search: "form",
+  error: "feedback",
+  alert: "feedback",
+  toast: "feedback",
+  notification: "feedback",
+  modal: "feedback",
+  dialog: "feedback"
+};
+function normalizeEnum(synonyms) {
+  return (v) => {
+    const trimmed = v.trim().toLowerCase();
+    return synonyms[trimmed] ?? trimmed;
+  };
+}
+var RouteGroupSchema = z.object({
+  id: z.string(),
+  layout: z.string().transform(normalizeEnum(LAYOUT_SYNONYMS)).pipe(z.enum(["header", "sidebar", "both", "none"])),
+  pages: z.array(z.string())
+});
+var PlannedComponentSchema = z.object({
+  name: z.string(),
+  description: z.string().default(""),
+  props: z.string().default("{}"),
+  usedBy: z.array(z.string()).default([]),
+  type: z.string().transform(normalizeEnum(COMPONENT_TYPE_SYNONYMS)).pipe(z.enum(["layout", "navigation", "data-display", "form", "feedback", "section", "widget"])).catch("section"),
+  shadcnDeps: z.array(z.string()).default([])
+});
+var PageNoteSchema = z.object({
+  type: z.string().transform(normalizeEnum(PAGE_TYPE_SYNONYMS)).pipe(z.enum(["marketing", "app", "auth"])),
+  sections: z.array(z.string()).default([]),
+  links: z.record(z.string()).optional()
+});
+var ArchitecturePlanSchema = z.object({
+  appName: z.string().optional(),
+  groups: z.array(RouteGroupSchema),
+  sharedComponents: z.array(PlannedComponentSchema).max(8).default([]),
+  pageNotes: z.record(z.string(), PageNoteSchema).default({})
+});
+function routeToKey(route) {
+  return route.replace(/^\//, "") || "home";
+}
+function getPageGroup(route, plan) {
+  return plan.groups.find((g) => g.pages.includes(route));
+}
+function getPageType(route, plan) {
+  return plan.pageNotes[routeToKey(route)]?.type ?? inferPageTypeFromRoute(route);
+}
+var PLAN_SYSTEM_PROMPT = `You are a UI architect. Given a list of pages for a web application, create a Component Architecture Plan as JSON.
+
+Your task:
+1. Group pages by navigation context (e.g., public marketing pages, authenticated app pages, auth flows)
+2. Identify reusable UI components that appear on 2+ pages
+3. Describe each page's sections and cross-page links
+
+Rules:
+- Each group gets a layout type: "header" (horizontal nav), "sidebar" (vertical nav), "both", or "none" (no nav)
+- Shared components must be genuinely reusable (appear on 2+ pages). Do NOT create a shared component for patterns used on only one page.
+- Page types: "marketing" (landing, features, pricing \u2014 spacious, section-based), "app" (dashboard, settings \u2014 compact, data-dense), "auth" (login, register \u2014 centered card form)
+- Component props should be a TypeScript-like interface string
+- shadcnDeps lists the shadcn/ui atoms the component will need (e.g., "card", "badge", "avatar")
+- Cross-page links: map link labels to target routes (e.g., {"Sign in": "/login"})
+- Maximum 8 shared components
+
+Respond with EXACTLY this JSON structure (use these exact field names):
+
+{
+  "appName": "MyApp",
+  "groups": [
+    { "id": "public", "layout": "header", "pages": ["/", "/pricing"] },
+    { "id": "app", "layout": "sidebar", "pages": ["/dashboard", "/settings"] },
+    { "id": "auth", "layout": "none", "pages": ["/login", "/register"] }
+  ],
+  "sharedComponents": [
+    {
+      "name": "StatCard",
+      "description": "Displays a single metric with label and value",
+      "props": "{ label: string; value: string; icon?: React.ReactNode }",
+      "usedBy": ["/dashboard", "/projects"],
+      "type": "widget",
+      "shadcnDeps": ["card"]
+    }
+  ],
+  "pageNotes": {
+    "home": { "type": "marketing", "sections": ["Hero", "Features", "Pricing"], "links": { "Sign in": "/login" } },
+    "dashboard": { "type": "app", "sections": ["Stats row", "Recent tasks", "Activity feed"] },
+    "login": { "type": "auth", "sections": ["Login form"] }
+  }
+}`;
+async function generateArchitecturePlan(pages, userMessage, aiProvider, layoutHint) {
+  const userPrompt = `Pages: ${pages.map((p) => `${p.name} (${p.route})`).join(", ")}
+
+User's request: "${userMessage}"
+
+Navigation type requested: ${layoutHint || "auto-detect"}`;
+  const warnings = [];
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const raw = await aiProvider.generateJSON(PLAN_SYSTEM_PROMPT, userPrompt);
+      const parsed = ArchitecturePlanSchema.safeParse(raw);
+      if (parsed.success) return { plan: parsed.data, warnings };
+      warnings.push(
+        `Validation (attempt ${attempt + 1}): ${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+      );
+    } catch (err) {
+      warnings.push(`Error (attempt ${attempt + 1}): ${err instanceof Error ? err.message : String(err)}`);
+      if (attempt === 1) return { plan: null, warnings };
+    }
+  }
+  return { plan: null, warnings };
+}
+async function updateArchitecturePlan(existingPlan, newPages, userMessage, aiProvider) {
+  const userPrompt = `Existing plan:
+${JSON.stringify(existingPlan, null, 2)}
+
+New pages to integrate: ${newPages.map((p) => `${p.name} (${p.route})`).join(", ")}
+
+User's request: "${userMessage}"
+
+Update the existing plan to include these new pages. Keep all existing groups, components, and pageNotes. Add the new pages to appropriate groups and add pageNotes for them.`;
+  try {
+    const raw = await aiProvider.generateJSON(PLAN_SYSTEM_PROMPT, userPrompt);
+    const parsed = ArchitecturePlanSchema.safeParse(raw);
+    if (parsed.success) return parsed.data;
+    const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    console.warn(chalk.dim(`  Plan update validation failed: ${issues}`));
+  } catch (err) {
+    console.warn(chalk.dim(`  Plan update error: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  const merged = structuredClone(existingPlan);
+  const largestGroup = merged.groups.reduce(
+    (best, g) => g.pages.length > (best?.pages.length ?? 0) ? g : best,
+    merged.groups[0]
+  );
+  for (const page of newPages) {
+    const alreadyPlaced = merged.groups.some((g) => g.pages.includes(page.route));
+    if (!alreadyPlaced && largestGroup) {
+      largestGroup.pages.push(page.route);
+    }
+    const key = routeToKey(page.route);
+    if (!merged.pageNotes[key]) {
+      merged.pageNotes[key] = { type: "app", sections: [] };
+    }
+  }
+  return merged;
+}
+var cachedPlan = null;
+function savePlan(projectRoot, plan) {
+  cachedPlan = null;
+  const dir = resolve(projectRoot, ".coherent");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(resolve(dir, "plan.json"), JSON.stringify(plan, null, 2));
+}
+function loadPlan(projectRoot) {
+  const planPath = resolve(projectRoot, ".coherent", "plan.json");
+  if (cachedPlan?.path === planPath) return cachedPlan.plan;
+  if (!existsSync(planPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(planPath, "utf-8"));
+    const parsed = ArchitecturePlanSchema.safeParse(raw);
+    if (!parsed.success) return null;
+    cachedPlan = { path: planPath, plan: parsed.data };
+    return parsed.data;
+  } catch {
+    return null;
+  }
+}
+function toKebabCase(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+async function generateSharedComponentsFromPlan(plan, styleContext, projectRoot, aiProvider) {
+  if (plan.sharedComponents.length === 0) return [];
+  const componentSpecs = plan.sharedComponents.map(
+    (c) => `- ${c.name}: ${c.description}. Props: ${c.props}. Type: ${c.type}. shadcn deps: ${c.shadcnDeps.join(", ") || "none"}`
+  ).join("\n");
+  const designRules = `${CORE_CONSTRAINTS}
+${getDesignQualityForType("app")}`;
+  const prompt = `Generate React components as separate files. For EACH component below, return an add-page request with name and pageCode fields.
+
+Components to generate:
+${componentSpecs}
+
+Style context: ${styleContext || "default"}
+
+${designRules}
+
+Requirements:
+- Each component MUST have \`export default function ComponentName\`
+- Use shadcn/ui imports from @/components/ui/*
+- Use Tailwind CSS classes matching the style context
+- TypeScript with proper props interface
+- Each component is a standalone file
+
+Return JSON with { requests: [{ type: "add-page", changes: { name: "ComponentName", pageCode: "..." } }, ...] }`;
+  const results = [];
+  try {
+    const raw = await aiProvider.parseModification(prompt);
+    const requests = Array.isArray(raw) ? raw : raw?.requests ?? [];
+    for (const comp of plan.sharedComponents) {
+      const match = requests.find(
+        (r) => r.type === "add-page" && r.changes?.name === comp.name
+      );
+      const code = match?.changes?.pageCode;
+      if (code && code.includes("export default")) {
+        const file = `components/shared/${toKebabCase(comp.name)}.tsx`;
+        results.push({ name: comp.name, code, file });
+      }
+    }
+  } catch {
+    for (const comp of plan.sharedComponents) {
+      try {
+        const singlePrompt = `Generate a React component: ${comp.name} \u2014 ${comp.description}. Props: ${comp.props}. shadcn deps: ${comp.shadcnDeps.join(", ") || "none"}. Style: ${styleContext || "default"}. Return { requests: [{ type: "add-page", changes: { name: "${comp.name}", pageCode: "..." } }] }`;
+        const raw = await aiProvider.parseModification(singlePrompt);
+        const requests = Array.isArray(raw) ? raw : raw?.requests ?? [];
+        const match = requests.find(
+          (r) => r.type === "add-page" && r.changes?.name === comp.name
+        );
+        const code = match?.changes?.pageCode;
+        if (code && code.includes("export default")) {
+          const file = `components/shared/${toKebabCase(comp.name)}.tsx`;
+          results.push({ name: comp.name, code, file });
+        }
+      } catch {
+      }
+    }
+  }
+  for (const comp of results) {
+    const planned = plan.sharedComponents.find((c) => c.name === comp.name);
+    await generateSharedComponent(projectRoot, {
+      name: comp.name,
+      type: planned?.type ?? "section",
+      code: comp.code,
+      description: planned?.description,
+      usedIn: planned?.usedBy ?? [],
+      source: "generated",
+      overwrite: true
+    });
+  }
+  return results;
+}
+
+export {
+  RouteGroupSchema,
+  PlannedComponentSchema,
+  PageNoteSchema,
+  ArchitecturePlanSchema,
+  routeToKey,
+  getPageGroup,
+  getPageType,
+  generateArchitecturePlan,
+  updateArchitecturePlan,
+  savePlan,
+  loadPlan,
+  generateSharedComponentsFromPlan
+};

package/dist/component-extractor-VYJLT5NR.js

@@ -0,0 +1,56 @@
+import "./chunk-3RG5ZIWI.js";
+
+// src/utils/component-extractor.ts
+function extractExportedComponentName(code) {
+  const patterns = [
+    /export\s+(?:default\s+)?function\s+([A-Z][a-zA-Z0-9]*)/,
+    /export\s+const\s+([A-Z][a-zA-Z0-9]*)\s*[=:]/
+  ];
+  for (const pattern of patterns) {
+    const match = code.match(pattern);
+    if (match) return match[1];
+  }
+  return null;
+}
+function extractPropsInterface(code) {
+  const interfaceMatch = code.match(/(?:interface|type)\s+Props\s*=?\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/);
+  if (interfaceMatch) {
+    const fields = interfaceMatch[1].split("\n").map((l) => l.trim().replace(/;?\s*$/, "")).filter((l) => l && !l.startsWith("//"));
+    return `{ ${fields.join("; ")} }`;
+  }
+  const inlineMatch = code.match(/\}\s*:\s*(\{[^)]+\})/);
+  if (inlineMatch) return inlineMatch[1].replace(/\s+/g, " ").trim();
+  return null;
+}
+function extractDependencies(code) {
+  const deps = [];
+  const importRegex = /import\s+.*?from\s+['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = importRegex.exec(code)) !== null) {
+    const source = match[1];
+    if (source.startsWith("@/components/ui/")) {
+      deps.push(source.replace("@/", ""));
+    } else if (!source.startsWith(".") && !source.startsWith("@/")) {
+      deps.push(source);
+    }
+  }
+  return [...new Set(deps)];
+}
+function extractUsageExample(pageCode, componentName) {
+  const selfClosingRegex = new RegExp(`<${componentName}\\s[^>]*/>`);
+  const selfMatch = pageCode.match(selfClosingRegex);
+  if (selfMatch) return selfMatch[0];
+  const openingRegex = new RegExp(`<${componentName}[\\s>][^]*?</${componentName}>`);
+  const openMatch = pageCode.match(openingRegex);
+  if (openMatch) {
+    const full = openMatch[0];
+    return full.length > 200 ? full.slice(0, 200) + "..." : full;
+  }
+  return null;
+}
+export {
+  extractDependencies,
+  extractExportedComponentName,
+  extractPropsInterface,
+  extractUsageExample
+};

package/dist/design-constraints-EIP2XM7T.js

@@ -0,0 +1,43 @@
+import {
+  CORE_CONSTRAINTS,
+  DESIGN_CONSTRAINTS,
+  DESIGN_QUALITY,
+  DESIGN_QUALITY_COMMON,
+  DESIGN_THINKING,
+  INTERACTION_PATTERNS,
+  RULES_CARDS_LAYOUT,
+  RULES_COMPONENTS_MISC,
+  RULES_CONTENT,
+  RULES_DATA_DISPLAY,
+  RULES_FEEDBACK,
+  RULES_FORMS,
+  RULES_NAVIGATION,
+  RULES_OVERLAYS,
+  RULES_SHADCN_APIS,
+  VISUAL_DEPTH,
+  getDesignQualityForType,
+  inferPageTypeFromRoute,
+  selectContextualRules
+} from "./chunk-5AHG4NNX.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  CORE_CONSTRAINTS,
+  DESIGN_CONSTRAINTS,
+  DESIGN_QUALITY,
+  DESIGN_QUALITY_COMMON,
+  DESIGN_THINKING,
+  INTERACTION_PATTERNS,
+  RULES_CARDS_LAYOUT,
+  RULES_COMPONENTS_MISC,
+  RULES_CONTENT,
+  RULES_DATA_DISPLAY,
+  RULES_FEEDBACK,
+  RULES_FORMS,
+  RULES_NAVIGATION,
+  RULES_OVERLAYS,
+  RULES_SHADCN_APIS,
+  VISUAL_DEPTH,
+  getDesignQualityForType,
+  inferPageTypeFromRoute,
+  selectContextualRules
+};