@getcoherent/cli 0.6.13 → 0.6.15

package/dist/ai-classifier-EGXPFJLN.js

@@ -0,0 +1,42 @@
+import "./chunk-3RG5ZIWI.js";
+
+// src/utils/ai-classifier.ts
+import { z } from "zod";
+var VALID_TYPES = ["layout", "navigation", "data-display", "form", "feedback", "section", "widget"];
+function buildClassificationPrompt(components) {
+  const specs = components.map((c, i) => `${i + 1}. ${c.name}: ${c.signature}`).join("\n");
+  return `Classify these React components into one of these types: ${VALID_TYPES.join(", ")}.
+
+${specs}
+
+Return JSON array: [{ "name": "...", "type": "...", "description": "one sentence" }]`;
+}
+var ClassificationSchema = z.array(
+  z.object({
+    name: z.string(),
+    type: z.string(),
+    description: z.string().default("")
+  })
+);
+function parseClassificationResponse(response) {
+  const jsonMatch = response.match(/\[[\s\S]*\]/);
+  if (!jsonMatch) return [];
+  const parsed = ClassificationSchema.safeParse(JSON.parse(jsonMatch[0]));
+  if (!parsed.success) return [];
+  return parsed.data.map((item) => ({
+    name: item.name,
+    type: VALID_TYPES.includes(item.type) ? item.type : "section",
+    description: item.description
+  }));
+}
+async function classifyComponents(components, aiCall) {
+  if (components.length === 0) return [];
+  const prompt = buildClassificationPrompt(components);
+  const response = await aiCall(prompt);
+  return parseClassificationResponse(response);
+}
+export {
+  buildClassificationPrompt,
+  classifyComponents,
+  parseClassificationResponse
+};

package/dist/ai-provider-CGSIYFZT.js

@@ -0,0 +1,13 @@
+import {
+  createAIProvider,
+  detectAIProvider,
+  getAPIKey,
+  hasAnyAPIKey
+} from "./chunk-SPQZBQYY.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  createAIProvider,
+  detectAIProvider,
+  getAPIKey,
+  hasAnyAPIKey
+};

package/dist/{chunk-CLPILU3Z.js → chunk-5AHG4NNX.js}

@@ -1,10 +1,3 @@
-// src/commands/chat/plan-generator.ts
-import { z } from "zod";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, resolve } from "path";
-import { mkdir, writeFile } from "fs/promises";
-import chalk from "chalk";
-
 // src/agents/design-constraints.ts
 var DESIGN_THINKING = `
 ## DESIGN THINKING (answer internally BEFORE writing code)
@@ -1026,279 +1019,6 @@ ${RULES_CONTENT}
 ${RULES_CARDS_LAYOUT}
 ${RULES_COMPONENTS_MISC}`;
 
-// src/commands/chat/plan-generator.ts
-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"
-};
-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(["section", "widget"])).catch("widget"),
-  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 fullPath = resolve(projectRoot, comp.file);
-    await mkdir(dirname(fullPath), { recursive: true });
-    await writeFile(fullPath, comp.code, "utf-8");
-  }
-  return results;
-}
-
 export {
   DESIGN_THINKING,
   CORE_CONSTRAINTS,
@@ -1307,18 +1027,16 @@ export {
   inferPageTypeFromRoute,
   DESIGN_QUALITY,
   VISUAL_DEPTH,
+  RULES_FORMS,
+  RULES_DATA_DISPLAY,
+  RULES_NAVIGATION,
+  RULES_OVERLAYS,
+  RULES_FEEDBACK,
+  RULES_CONTENT,
+  RULES_CARDS_LAYOUT,
+  RULES_SHADCN_APIS,
+  RULES_COMPONENTS_MISC,
   INTERACTION_PATTERNS,
   selectContextualRules,
-  RouteGroupSchema,
-  PlannedComponentSchema,
-  PageNoteSchema,
-  ArchitecturePlanSchema,
-  routeToKey,
-  getPageGroup,
-  getPageType,
-  generateArchitecturePlan,
-  updateArchitecturePlan,
-  savePlan,
-  loadPlan,
-  generateSharedComponentsFromPlan
+  DESIGN_CONSTRAINTS
 };