create-fornix 0.0.1

package/dist/index.js

@@ -0,0 +1,4612 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { runMain } from "citty";
+
+// src/cli/index.ts
+import { defineCommand as defineCommand8 } from "citty";
+
+// src/cli/commands/create.ts
+import { defineCommand } from "citty";
+import { resolve, basename as basename2 } from "path";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+import * as p2 from "@clack/prompts";
+import pc3 from "picocolors";
+
+// src/utils/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+
+// src/scaffold/config-validator.ts
+function validateConfig(config, manifests) {
+  const errors = [];
+  checkBlocksExist(config, manifests, errors);
+  checkRequiredModes(config, manifests, errors);
+  checkDatabaseRequiresServer(config, errors);
+  checkDefaultLocaleInLocales(config, errors);
+  if (errors.length > 0) {
+    return err(errors);
+  }
+  return ok(config);
+}
+function checkBlocksExist(config, manifests, errors) {
+  for (const block of config.blocks) {
+    if (!(block.name in manifests)) {
+      errors.push({
+        field: "blocks",
+        message: `Block '${block.name}' not found in registry`
+      });
+    }
+  }
+}
+function checkRequiredModes(config, manifests, errors) {
+  if (config.renderMode === "static") {
+    for (const block of config.blocks) {
+      const manifest2 = manifests[block.name];
+      if (manifest2?.requiredMode === "server" || manifest2?.requiredMode === "hybrid") {
+        errors.push({
+          field: "blocks",
+          message: `Block '${block.name}' requires '${manifest2.requiredMode}' rendering, but config uses 'static' mode`
+        });
+      }
+    }
+  }
+}
+function checkDatabaseRequiresServer(config, errors) {
+  if (config.database !== "none" && config.renderMode === "static") {
+    errors.push({
+      field: "database",
+      message: `Database '${config.database}' requires server or hybrid rendering, but config uses 'static' mode`
+    });
+  }
+}
+function checkDefaultLocaleInLocales(config, errors) {
+  if (!config.locales.includes(config.defaultLocale)) {
+    errors.push({
+      field: "defaultLocale",
+      message: `defaultLocale '${config.defaultLocale}' is not in the locales array [${config.locales.join(", ")}]`
+    });
+  }
+}
+
+// src/scaffold/dependency-resolver.ts
+function resolveDependencies(selected, manifests) {
+  const unique = [...new Set(selected)];
+  for (const name of unique) {
+    if (!(name in manifests)) {
+      return err({
+        kind: "BlockNotFoundError",
+        message: `Block '${name}' not found in registry`,
+        blockName: name
+      });
+    }
+  }
+  const allBlocks = /* @__PURE__ */ new Set();
+  const collectError = collectTransitiveDependencies(
+    unique,
+    manifests,
+    allBlocks,
+    /* @__PURE__ */ new Set()
+  );
+  if (collectError !== void 0) {
+    return err(collectError);
+  }
+  const conflictError = detectConflicts(allBlocks, manifests);
+  if (conflictError !== void 0) {
+    return err(conflictError);
+  }
+  const sortResult = topologicalSort(allBlocks, manifests);
+  if (sortResult === void 0) {
+    return err({
+      kind: "CircularDependencyError",
+      message: "Unexpected circular dependency detected during sort",
+      chain: []
+    });
+  }
+  return ok(sortResult);
+}
+function collectTransitiveDependencies(blocks, manifests, collected, visiting) {
+  for (const name of blocks) {
+    if (collected.has(name)) {
+      continue;
+    }
+    if (visiting.has(name)) {
+      return {
+        kind: "CircularDependencyError",
+        message: `Circular dependency detected involving '${name}'`,
+        chain: [...visiting, name]
+      };
+    }
+    if (!(name in manifests)) {
+      return {
+        kind: "BlockNotFoundError",
+        message: `Block '${name}' not found in registry (required as dependency)`,
+        blockName: name
+      };
+    }
+    visiting.add(name);
+    const manifest2 = manifests[name];
+    if (manifest2.requires.length > 0) {
+      const depError = collectTransitiveDependencies(
+        manifest2.requires,
+        manifests,
+        collected,
+        visiting
+      );
+      if (depError !== void 0) {
+        return depError;
+      }
+    }
+    visiting.delete(name);
+    collected.add(name);
+  }
+  return void 0;
+}
+function detectConflicts(blocks, manifests) {
+  for (const name of blocks) {
+    const manifest2 = manifests[name];
+    for (const conflicting of manifest2.conflicts) {
+      if (blocks.has(conflicting)) {
+        return {
+          kind: "DependencyConflictError",
+          message: `Block '${name}' conflicts with '${conflicting}'`,
+          blockA: name,
+          blockB: conflicting
+        };
+      }
+    }
+  }
+  return void 0;
+}
+function topologicalSort(blocks, manifests) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const name of blocks) {
+    if (!inDegree.has(name)) {
+      inDegree.set(name, 0);
+    }
+    if (!dependents.has(name)) {
+      dependents.set(name, []);
+    }
+  }
+  for (const name of blocks) {
+    const manifest2 = manifests[name];
+    for (const dep of manifest2.requires) {
+      if (blocks.has(dep)) {
+        inDegree.set(name, (inDegree.get(name) ?? 0) + 1);
+        const list = dependents.get(dep) ?? [];
+        list.push(name);
+        dependents.set(dep, list);
+      }
+    }
+  }
+  const queue = [];
+  for (const [name, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(name);
+    }
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(current);
+    for (const dependent of dependents.get(current) ?? []) {
+      const newDegree = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, newDegree);
+      if (newDegree === 0) {
+        queue.push(dependent);
+      }
+    }
+  }
+  if (sorted.length !== blocks.size) {
+    return void 0;
+  }
+  return sorted;
+}
+
+// src/scaffold/structure-generator.ts
+function generateStructure(config) {
+  const files = {};
+  const adapterDeps = getAdapterDependencies(config);
+  const pkg = {
+    name: config.projectName,
+    type: "module",
+    version: "0.0.1",
+    scripts: {
+      dev: "astro dev",
+      start: "astro dev",
+      build: "astro check && astro build",
+      preview: "astro preview",
+      astro: "astro"
+    },
+    dependencies: {
+      astro: "^5.2.0",
+      "@astrojs/check": "^0.9.0",
+      ...config.cssEngine === "tailwind" && {
+        tailwindcss: "^4.0.0",
+        "@tailwindcss/vite": "^4.0.0"
+      },
+      ...adapterDeps
+    },
+    devDependencies: {
+      typescript: "^5.7.0"
+    }
+  };
+  files["package.json"] = JSON.stringify(pkg, null, 2) + "\n";
+  const tsconfig = {
+    extends: "astro/tsconfigs/strict",
+    compilerOptions: {
+      jsx: "preserve",
+      jsxImportSource: "react",
+      // Even if not using React yet, good default for UI frameworks
+      strictNullChecks: true,
+      baseUrl: ".",
+      paths: {
+        "@/*": ["src/*"]
+      }
+    }
+  };
+  files["tsconfig.json"] = JSON.stringify(tsconfig, null, 2) + "\n";
+  files[".gitignore"] = `
+# build output
+dist/
+.astro/
+
+# dependencies
+node_modules/
+
+# logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# environment variables
+.env
+.env.production
+.env.development
+
+# OS files
+.DS_Store
+Thumbs.db
+`.trim() + "\n";
+  files["src/pages/index.astro"] = `
+---
+import Layout from '../layouts/Layout.astro';
+---
+<Layout title="Welcome to Astro.">
+  <main>
+    <h1>Welcome to <span class="text-gradient">${config.projectName}</span></h1>
+  </main>
+</Layout>
+`.trim() + "\n";
+  files["src/layouts/Layout.astro"] = `
+---
+interface Props {
+  title: string;
+}
+const { title } = Astro.props;
+---
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="description" content="Astro description" />
+    <meta name="viewport" content="width=device-width" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="generator" content={Astro.generator} />
+    <title>{title}</title>
+  </head>
+  <body>
+    <slot />
+  </body>
+</html>
+`.trim() + "\n";
+  if (config.deployTarget === "cloudflare") {
+    const wrangler = {
+      name: config.projectName,
+      compatibility_date: "2025-02-14",
+      // ... Add observability/pages_build_output_dir as needed.
+      // Basic structure:
+      pages_build_output_dir: "dist",
+      observability: {
+        enabled: true
+      }
+    };
+    files["wrangler.json"] = JSON.stringify(wrangler, null, 2) + "\n";
+  }
+  return files;
+}
+function getAdapterDependencies(config) {
+  if (config.renderMode === "static" && config.deployTarget === "static") {
+    return {};
+  }
+  const adapterMap = {
+    cloudflare: { "@astrojs/cloudflare": "^12.0.0" },
+    vercel: { "@astrojs/vercel": "^8.0.0" },
+    netlify: { "@astrojs/netlify": "^6.0.0" }
+  };
+  return adapterMap[config.deployTarget] ?? {};
+}
+
+// src/scaffold/config-generators/astro-config.ts
+import { parseModule, generateCode, builders } from "magicast";
+var ADAPTER_MAP = {
+  cloudflare: { package: "@astrojs/cloudflare", identifier: "cloudflare" },
+  vercel: { package: "@astrojs/vercel", identifier: "vercel" },
+  netlify: { package: "@astrojs/netlify", identifier: "netlify" }
+};
+function generateAstroConfig(config, blocks = []) {
+  try {
+    const module = parseModule("export default defineConfig({});");
+    module.imports.$add({
+      from: "astro/config",
+      imported: "defineConfig",
+      local: "defineConfig"
+    });
+    const configObject = module.exports.default.$args[0];
+    if (config.renderMode === "server") {
+      configObject.output = "server";
+    }
+    const adapter = ADAPTER_MAP[config.deployTarget];
+    if (adapter) {
+      module.imports.$add({
+        from: adapter.package,
+        imported: "default",
+        local: adapter.identifier
+      });
+      configObject.adapter = builders.functionCall(adapter.identifier);
+    }
+    if (config.locales.length >= 2) {
+      configObject.i18n = {
+        defaultLocale: config.defaultLocale,
+        locales: config.locales,
+        routing: {
+          prefixDefaultLocale: false
+        }
+      };
+    }
+    const hasMdx = blocks.some((b) => b.dependencies && b.dependencies["@astrojs/mdx"]);
+    if (hasMdx) {
+      module.imports.$add({
+        from: "@astrojs/mdx",
+        imported: "default",
+        local: "mdx"
+      });
+      configObject.integrations = configObject.integrations || [];
+      configObject.integrations.push(builders.functionCall("mdx"));
+    }
+    const { code } = generateCode(module);
+    return ok(code);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return err(new Error(`Failed to generate astro.config.mjs: ${message}`));
+  }
+}
+
+// src/scaffold/config-generators/tailwind-config.ts
+function generateTailwindConfig(config) {
+  if (config.cssEngine !== "tailwind") {
+    return ok(null);
+  }
+  const themeBlock = [
+    "@theme {",
+    "  --color-primary: var(--color-primary);",
+    "  --color-secondary: var(--color-secondary);",
+    "  --color-accent: var(--color-accent);",
+    "  --color-background: var(--color-background);",
+    "  --color-foreground: var(--color-foreground);",
+    "}"
+  ].join("\n");
+  const lines = [
+    '@import "tailwindcss";',
+    "",
+    `@source "../src/**/*.{astro,html,js,jsx,md,mdx,svelte,ts,tsx,vue}";`,
+    "",
+    themeBlock,
+    ""
+  ];
+  return ok(lines.join("\n"));
+}
+
+// src/scaffold/config-generators/palette-css.ts
+var COLOR_TOKENS = [
+  "primary",
+  "secondary",
+  "accent",
+  "background",
+  "foreground"
+];
+var CURRENT_PATH = "src/styles/palettes/_current.css";
+function generatePaletteCSS(palette, themeSwitcher, allPalettes) {
+  try {
+    const files = {};
+    files[CURRENT_PATH] = buildPaletteFile(palette.colors);
+    if (themeSwitcher && allPalettes && allPalettes.length > 0) {
+      for (const registryPalette of allPalettes) {
+        const path = `src/styles/palettes/${registryPalette.name}.css`;
+        files[path] = buildPaletteFile(registryPalette.colors);
+      }
+      const paletteNames = allPalettes.map((palette2) => palette2.name);
+      const script = buildSwitcherScript(paletteNames);
+      return ok({ files, switcherScript: script });
+    }
+    return ok({ files });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return err(new Error(`Failed to generate palette CSS: ${message}`));
+  }
+}
+function buildPaletteFile(colors) {
+  const properties = COLOR_TOKENS.map(
+    (token) => `  --color-${token}: ${colors[token]};`
+  ).join("\n");
+  return `:root {
+${properties}
+}
+`;
+}
+function buildSwitcherScript(paletteNames) {
+  return `(function () {
+  const PALETTES = ${JSON.stringify(paletteNames)};
+  const STORAGE_KEY = "fornix-palette";
+
+  function loadPalette(name) {
+    const link = document.getElementById("fornix-palette-link");
+    if (link) {
+      link.setAttribute("href", "/styles/palettes/" + name + ".css");
+    }
+    localStorage.setItem(STORAGE_KEY, name);
+  }
+
+  function getCurrentPalette() {
+    return localStorage.getItem(STORAGE_KEY) || PALETTES[0];
+  }
+
+  document.addEventListener("DOMContentLoaded", function () {
+    const saved = getCurrentPalette();
+    loadPalette(saved);
+  });
+
+  window.__fornixSwitchPalette = loadPalette;
+  window.__fornixPalettes = PALETTES;
+})();
+`;
+}
+
+// src/scaffold/block-placer.ts
+function placeBlocks(blocks, blockSources, config) {
+  const files = {};
+  const context = {
+    renderMode: config.renderMode,
+    deployTarget: config.deployTarget,
+    cssEngine: config.cssEngine,
+    database: config.database
+  };
+  for (const block of blocks) {
+    const sources = blockSources[block.name];
+    if (!sources) {
+      return err(
+        new Error(
+          `Block source content not found for '${block.name}'`
+        )
+      );
+    }
+    for (const file of block.files) {
+      if (file.condition && !evaluateCondition(file.condition, context)) {
+        continue;
+      }
+      const content = sources[file.source];
+      if (content === void 0) {
+        return err(
+          new Error(
+            `Source file '${file.source}' not found in block '${block.name}'`
+          )
+        );
+      }
+      files[file.destination] = content;
+    }
+  }
+  return ok(files);
+}
+function evaluateCondition(condition, context) {
+  const notEqualsMatch = condition.match(
+    /^(\w+)\s*!==\s*'([^']*)'$/
+  );
+  if (notEqualsMatch) {
+    const [, field, value] = notEqualsMatch;
+    const contextValue = getContextValue(field, context);
+    return contextValue !== value;
+  }
+  const equalsMatch = condition.match(
+    /^(\w+)\s*===\s*'([^']*)'$/
+  );
+  if (equalsMatch) {
+    const [, field, value] = equalsMatch;
+    const contextValue = getContextValue(field, context);
+    return contextValue === value;
+  }
+  return true;
+}
+function getContextValue(field, context) {
+  if (field in context) {
+    return context[field];
+  }
+  return void 0;
+}
+
+// src/scaffold/content-wiring.ts
+var TYPE_DIRECTORY = {
+  section: "sections",
+  integration: "integrations",
+  feature: "features",
+  layout: "layouts"
+};
+function wireContent(blocks, defaultContent, config) {
+  const files = {};
+  const isMultiLocale = config.locales.length >= 2;
+  const blocksWithContent = blocks.filter(
+    (block) => block.ai?.contentSlots !== void 0 && Object.keys(block.ai.contentSlots).length > 0 || block.collections !== void 0 && block.collections.length > 0
+  );
+  if (blocksWithContent.length === 0) {
+    return ok(files);
+  }
+  files["src/content/config.ts"] = generateContentConfig(blocksWithContent);
+  for (const block of blocksWithContent) {
+    if (!block.ai?.contentSlots || Object.keys(block.ai.contentSlots).length === 0) {
+      continue;
+    }
+    const subdirectory = TYPE_DIRECTORY[block.type] ?? block.type;
+    const content = defaultContent[block.name] ?? buildDefaultFromSlots(block.ai.contentSlots);
+    const jsonContent = JSON.stringify(content, null, 2) + "\n";
+    if (isMultiLocale) {
+      for (const locale of config.locales) {
+        const path = `src/content/${locale}/${subdirectory}/${block.name}.json`;
+        files[path] = jsonContent;
+      }
+    } else {
+      const path = `src/content/${subdirectory}/${block.name}.json`;
+      files[path] = jsonContent;
+    }
+  }
+  return ok(files);
+}
+function generateContentConfig(blocks) {
+  const imports = [
+    'import { defineCollection, z } from "astro:content";'
+  ];
+  const collections = [];
+  for (const block of blocks) {
+    if (block.collections && block.collections.length > 0) {
+      for (const col of block.collections) {
+        const importName = `${block.name.replace(/-/g, "")}${col.name}Schema`;
+        const importPath = col.schemaSource.replace(/\.ts$/, "");
+        imports.push(`import { schema as ${importName} } from "${importPath}";`);
+        collections.push(
+          `  "${col.name}": defineCollection({
+    type: "${col.type}",
+    schema: ${importName},
+  })`
+        );
+      }
+    }
+    const slots = block.ai?.contentSlots;
+    if (slots && Object.keys(slots).length > 0) {
+      const schemaFields = Object.entries(slots).map(([name, slot]) => `    ${name}: ${zodTypeForSlot(slot)},`).join("\n");
+      collections.push(
+        `  "${block.name}": defineCollection({
+    type: "data",
+    schema: z.object({
+${schemaFields}
+    }),
+  })`
+      );
+    }
+  }
+  const lines = [
+    ...imports,
+    "",
+    "export const collections = {",
+    collections.join(",\n"),
+    "};",
+    ""
+  ];
+  return lines.join("\n");
+}
+function zodTypeForSlot(slot) {
+  switch (slot.type) {
+    case "string":
+      return "z.string()";
+    case "number":
+      return "z.number()";
+    case "boolean":
+      return "z.boolean()";
+    case "array":
+      return "z.array(z.unknown())";
+    case "object":
+      return "z.record(z.unknown())";
+  }
+}
+function buildDefaultFromSlots(slots) {
+  const content = {};
+  for (const [name, slot] of Object.entries(slots)) {
+    content[name] = defaultValueForType(slot.type);
+  }
+  return content;
+}
+function defaultValueForType(type) {
+  switch (type) {
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return {};
+  }
+}
+
+// src/scaffold/i18n-wiring.ts
+function wireI18n(config) {
+  const files = {};
+  if (config.locales.length < 2) {
+    return ok(files);
+  }
+  files["src/i18n/utils.ts"] = generateI18nUtils(config);
+  files["src/pages/[locale]/index.astro"] = generateLocaleIndexPage(config);
+  return ok(files);
+}
+function generateI18nUtils(config) {
+  const localesArray = config.locales.map((locale) => `"${locale}"`).join(", ");
+  return `export const locales = [${localesArray}] as const;
+export type Locale = (typeof locales)[number];
+export const defaultLocale: Locale = "${config.defaultLocale}";
+
+/**
+ * Gets the current locale from the URL pathname.
+ * Falls back to the default locale if not found.
+ */
+export function getLocale(pathname: string): Locale {
+  const segments = pathname.split("/").filter(Boolean);
+  const candidate = segments[0];
+  if (candidate && (locales as readonly string[]).includes(candidate)) {
+    return candidate as Locale;
+  }
+  return defaultLocale;
+}
+
+/**
+ * Simple translation lookup.
+ * Given a translations record keyed by locale, returns the value
+ * for the specified locale (or falls back to default).
+ */
+export function t<T>(
+  translations: Record<Locale, T>,
+  locale: Locale,
+): T {
+  return translations[locale] ?? translations[defaultLocale];
+}
+`;
+}
+function generateLocaleIndexPage(config) {
+  return `---
+import { locales } from "../../i18n/utils";
+import Layout from "../../layouts/Layout.astro";
+
+export function getStaticPaths() {
+  return locales.map((locale) => ({ params: { locale } }));
+}
+
+const { locale } = Astro.params;
+---
+<Layout title="${config.projectName}">
+  <main>
+    <h1>${config.projectName}</h1>
+    <p>Locale: {locale}</p>
+  </main>
+</Layout>
+`;
+}
+
+// src/scaffold/agent-context-generator.ts
+function getI18nInfo(config) {
+  if (config.locales.length >= 2) {
+    return `
+### i18n
+i18n is enabled. The project supports the following locales: \`${config.locales.join(", ")}\` with \`${config.defaultLocale}\` as default.
+Content is organized in locale-specific folders under \`src/content/\`:
+${config.locales.map((l) => `- \`src/content/${l}/\``).join("\n")}
+`;
+  }
+  return `
+### Content
+Content is located under \`src/content/\`.
+`;
+}
+function getBlocksTable(blocks) {
+  if (blocks.length === 0) return "No blocks installed.\n";
+  const rows = blocks.map((b) => `| \`${b.name}\` | ${b.type} | ${b.description} |`).join("\n");
+  return `| Block | Type | Description |
+|-------|------|-------------|
+${rows}
+`;
+}
+function generateAgentContext(config, blocks) {
+  const i18nSection = getI18nInfo(config);
+  const blocksTable = getBlocksTable(blocks);
+  const content = `# Fornix Project: ${config.projectName}
+
+## Architecture
+- **Render Mode:** ${config.renderMode}
+- **Deploy Target:** ${config.deployTarget}
+- **Database:** ${config.database}
+- **CSS Engine:** ${config.cssEngine}
+- **Package Manager:** ${config.packageManager}
+
+## Installed Blocks
+${blocksTable}
+## Content & Locales
+${i18nSection}
+## CLI Commands
+- \`npx create-fornix [dir]\` \u2014 scaffold a new project (AI mode default, \`--manual\` for interactive)
+- \`fornix add <block>\` / \`fornix remove <block>\` \u2014 manage blocks
+- \`fornix list\` / \`fornix status\` \u2014 inspect registry and project
+- \`fornix mcp serve\` \u2014 MCP server for AI agent integration
+
+> **Note to AI Agents:** You should respect the Fornix architectural guidelines by updating JSON content for text changes, and interacting via MCP rather than modifying block structures ad hoc.
+`;
+  const cursorContent = `---
+description: Fornix Project Architecture and Context
+globs: *
+---
+${content}
+`;
+  return {
+    "CLAUDE.md": content,
+    ".cursor/rules/fornix.mdc": cursorContent
+  };
+}
+
+// src/scaffold/pipeline.ts
+function scaffold(input) {
+  const { config, manifests, blockSources, blockDefaultContent, allPalettes } = input;
+  const validationResult = validateConfig(config, manifests);
+  if (!isOk(validationResult)) {
+    const messages = validationResult.error.map((validationError) => validationError.message).join("; ");
+    return err(new Error(`Config validation failed: ${messages}`));
+  }
+  const selectedBlockNames = config.blocks.map((block) => block.name);
+  const dependencyResult = resolveDependencies(selectedBlockNames, manifests);
+  if (!isOk(dependencyResult)) {
+    return err(new Error(`Dependency resolution failed: ${dependencyResult.error.message}`));
+  }
+  const resolvedBlockNames = dependencyResult.value;
+  const files = {};
+  const structureFiles = generateStructure(config);
+  Object.assign(files, structureFiles);
+  const resolvedManifests = resolvedBlockNames.filter((name) => manifests[name] !== void 0).map((name) => manifests[name]);
+  const astroConfigResult = generateAstroConfig(config, resolvedManifests);
+  if (!isOk(astroConfigResult)) {
+    return err(astroConfigResult.error);
+  }
+  files["astro.config.mjs"] = astroConfigResult.value;
+  const tailwindResult = generateTailwindConfig(config);
+  if (!isOk(tailwindResult)) {
+    return err(tailwindResult.error);
+  }
+  if (tailwindResult.value !== null) {
+    files["tailwind.css"] = tailwindResult.value;
+  }
+  const paletteResult = generatePaletteCSS(
+    config.palette,
+    config.themeSwitcher,
+    allPalettes.length > 0 ? allPalettes : void 0
+  );
+  if (!isOk(paletteResult)) {
+    return err(paletteResult.error);
+  }
+  Object.assign(files, paletteResult.value.files);
+  if (paletteResult.value.switcherScript) {
+    files["src/scripts/theme-switcher.js"] = paletteResult.value.switcherScript;
+  }
+  const blockPlaceResult = placeBlocks(resolvedManifests, blockSources, config);
+  if (!isOk(blockPlaceResult)) {
+    return err(blockPlaceResult.error);
+  }
+  Object.assign(files, blockPlaceResult.value);
+  const contentResult = wireContent(resolvedManifests, blockDefaultContent, config);
+  if (!isOk(contentResult)) {
+    return err(contentResult.error);
+  }
+  Object.assign(files, contentResult.value);
+  const i18nResult = wireI18n(config);
+  if (!isOk(i18nResult)) {
+    return err(i18nResult.error);
+  }
+  Object.assign(files, i18nResult.value);
+  const envVars = collectEnvVars(resolvedManifests);
+  if (envVars.length > 0) {
+    files[".env.example"] = generateEnvExample(envVars);
+  }
+  files["fornix.json"] = generateProjectManifest(config, resolvedManifests);
+  const agentContextFiles = generateAgentContext(config, resolvedManifests);
+  Object.assign(files, agentContextFiles);
+  return ok({ files, resolvedBlockNames });
+}
+function collectEnvVars(blocks) {
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    for (const envVar of block.envVars) {
+      if (!seen.has(envVar.name)) {
+        seen.add(envVar.name);
+        entries.push({
+          name: envVar.name,
+          description: envVar.description,
+          required: envVar.required,
+          blockName: block.name
+        });
+      }
+    }
+  }
+  return entries;
+}
+function generateEnvExample(envVars) {
+  const lines = [
+    "# Environment Variables",
+    "# Generated by Fornix \u2014 fill in your values",
+    ""
+  ];
+  for (const envVar of envVars) {
+    lines.push(`# ${envVar.description} (from ${envVar.blockName})`);
+    lines.push(`${envVar.name}=`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function generateProjectManifest(config, blocks) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const manifest2 = {
+    version: "1.0.0",
+    createdAt: now,
+    createdWith: config.createdWith,
+    renderMode: config.renderMode,
+    deployTarget: config.deployTarget,
+    database: config.database,
+    locales: config.locales,
+    defaultLocale: config.defaultLocale,
+    palette: config.palette,
+    themeSwitcher: config.themeSwitcher,
+    blocks: blocks.map((block) => ({
+      name: block.name,
+      version: block.version,
+      variant: config.blocks.find((selection) => selection.name === block.name)?.variant ?? "default",
+      installedAt: now
+    }))
+  };
+  return JSON.stringify(manifest2, null, 2) + "\n";
+}
+
+// src/cli/fixture-registry.ts
+import { readFileSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+function manifest(name, overrides = {}) {
+  return {
+    schemaVersion: 1,
+    name,
+    version: "1.0.0",
+    type: "section",
+    description: `Block ${name}`,
+    category: "general",
+    tags: [],
+    dependencies: {},
+    requires: [],
+    conflicts: [],
+    envVars: [],
+    variants: ["default"],
+    slots: [],
+    files: [
+      {
+        source: `${name}.astro`,
+        destination: `src/components/sections/${name}.astro`
+      }
+    ],
+    ...overrides
+  };
+}
+var FIXTURE_MANIFESTS = {
+  "hero-gradient": manifest("hero-gradient", {
+    category: "hero",
+    ai: {
+      whenToUse: "Landing page hero with gradient background",
+      whenNotToUse: "Internal pages",
+      pairsWith: ["cta-simple", "features-grid"],
+      contentSlots: {
+        headline: { type: "string", description: "Main headline" },
+        subheadline: { type: "string", description: "Sub headline" }
+      }
+    }
+  }),
+  "footer-minimal": manifest("footer-minimal", {
+    category: "footer"
+  }),
+  "cta-simple": manifest("cta-simple", {
+    category: "cta"
+  }),
+  "features-grid": manifest("features-grid", {
+    category: "features"
+  }),
+  "auth-better-auth": manifest("auth-better-auth", {
+    type: "integration",
+    category: "auth",
+    requiredMode: "server",
+    requires: ["db-d1"],
+    envVars: [
+      { name: "AUTH_SECRET", description: "Auth secret key", required: true },
+      { name: "GITHUB_CLIENT_ID", description: "GitHub OAuth client ID", required: true },
+      { name: "GITHUB_CLIENT_SECRET", description: "GitHub OAuth client secret", required: true }
+    ],
+    files: [
+      { source: "auth.ts", destination: "src/lib/auth.ts" },
+      { source: "middleware.ts", destination: "src/middleware/auth.ts" },
+      { source: "auth-api.ts", destination: "src/pages/api/auth/[...all].ts" },
+      { source: "login.astro", destination: "src/pages/login.astro" },
+      { source: "signup.astro", destination: "src/pages/signup.astro" }
+    ]
+  }),
+  "db-d1": manifest("db-d1", {
+    type: "integration",
+    category: "database",
+    requiredMode: "server",
+    envVars: [
+      { name: "D1_DATABASE_ID", description: "Cloudflare D1 database ID", required: true }
+    ],
+    files: [
+      { source: "db.ts", destination: "src/lib/db.ts" },
+      { source: "schema.ts", destination: "src/lib/db-schema.ts" },
+      { source: "drizzle.config.ts", destination: "drizzle.config.ts" },
+      { source: "migrations/.gitkeep", destination: "drizzle/migrations/.gitkeep" }
+    ]
+  }),
+  "blog-mdx": manifest("blog-mdx", {
+    type: "feature",
+    category: "blog",
+    files: [
+      { source: "schema.ts", destination: "src/content/blog-schema.ts" },
+      { source: "pages/index.astro", destination: "src/pages/blog/index.astro" },
+      { source: "pages/[slug].astro", destination: "src/pages/blog/[slug].astro" },
+      { source: "pages/rss.xml.ts", destination: "src/pages/rss.xml.ts" }
+    ]
+  }),
+  "docs-collection": manifest("docs-collection", {
+    type: "feature",
+    category: "docs",
+    files: [
+      { source: "schema.ts", destination: "src/content/docs-schema.ts" },
+      { source: "pages/[...slug].astro", destination: "src/pages/docs/[...slug].astro" }
+    ]
+  }),
+  "layout-marketing": manifest("layout-marketing", {
+    type: "layout",
+    category: "marketing",
+    files: [
+      { source: "layout-marketing.astro", destination: "src/layouts/layout-marketing.astro" },
+      { source: "default-content.json", destination: "src/content/layouts/layout-marketing.json" }
+    ],
+    ai: {
+      whenToUse: "marketing pages",
+      whenNotToUse: "dashboards",
+      pairsWith: [],
+      contentSlots: {
+        headerLinks: { type: "array" },
+        footerText: { type: "string" }
+      }
+    }
+  }),
+  "layout-docs": manifest("layout-docs", {
+    type: "layout",
+    category: "docs",
+    files: [
+      { source: "layout-docs.astro", destination: "src/layouts/layout-docs.astro" },
+      { source: "default-content.json", destination: "src/content/layouts/layout-docs.json" }
+    ],
+    ai: {
+      whenToUse: "docs",
+      whenNotToUse: "marketing",
+      pairsWith: [],
+      contentSlots: {
+        headerTitle: { type: "string" },
+        footerText: { type: "string" }
+      }
+    }
+  }),
+  "layout-dashboard": manifest("layout-dashboard", {
+    type: "layout",
+    category: "dashboard",
+    requiredMode: "server",
+    requires: ["auth-better-auth"],
+    files: [
+      { source: "layout-dashboard.astro", destination: "src/layouts/layout-dashboard.astro" },
+      { source: "default-content.json", destination: "src/content/layouts/layout-dashboard.json" }
+    ],
+    ai: {
+      whenToUse: "dashboards",
+      whenNotToUse: "marketing",
+      pairsWith: [],
+      contentSlots: {
+        sidebarLinks: { type: "array" },
+        logoutText: { type: "string" }
+      }
+    }
+  }),
+  "hero-video": manifest("hero-video"),
+  "features-bento": manifest("features-bento"),
+  "pricing-table": manifest("pricing-table"),
+  "faq-accordion": manifest("faq-accordion"),
+  "footer-rich": manifest("footer-rich"),
+  "testimonials-carousel": manifest("testimonials-carousel"),
+  "contact-form": manifest("contact-form"),
+  "hero-split": manifest("hero-split"),
+  "header-transparent": manifest("header-transparent"),
+  "cta-newsletter": manifest("cta-newsletter"),
+  "header-sticky": manifest("header-sticky")
+};
+var FIXTURE_BLOCK_SOURCES = {
+  "hero-gradient": {
+    "hero-gradient.astro": `---
+interface Props {
+  headline?: string;
+  subheadline?: string;
+}
+const { headline = "Welcome", subheadline = "" } = Astro.props;
+---
+<section class="hero-gradient">
+  <h1>{headline}</h1>
+  {subheadline && <p>{subheadline}</p>}
+</section>
+`
+  },
+  "footer-minimal": {
+    "footer-minimal.astro": `<footer class="footer-minimal">
+  <p>&copy; {new Date().getFullYear()}</p>
+</footer>
+`
+  },
+  "cta-simple": {
+    "cta-simple.astro": `<section class="cta-simple">
+  <h2>Get Started</h2>
+  <a href="#" class="btn">Start Now</a>
+</section>
+`
+  },
+  "features-grid": {
+    "features-grid.astro": `<section class="features-grid">
+  <h2>Features</h2>
+  <div class="grid"></div>
+</section>
+`
+  },
+  "auth-better-auth": {
+    "auth.ts": `import { getDb } from "./db";
+
+type D1Database = any;
+
+export function createAuth(d1: D1Database) {
+  const db = getDb(d1);
+  return { handler: (req: Request) => new Response("auth") };
+}
+`,
+    "middleware.ts": `import type { MiddlewareHandler } from "astro";
+import { createAuth } from "../lib/auth";
+
+export const authMiddleware: MiddlewareHandler = async (context, next) => {
+  return next();
+};
+`,
+    "auth-api.ts": `import type { APIRoute } from "astro";
+import { createAuth } from "../../../lib/auth";
+
+export const ALL: APIRoute = async (context) => {
+  const d1 = (context.locals as Record<string, { env: { DB: any } }>).runtime.env.DB;
+  const auth = createAuth(d1);
+  return auth.handler(context.request);
+};
+`,
+    "login.astro": `---
+---
+<main class="auth-page"><h1>Login</h1></main>
+`,
+    "signup.astro": `---
+---
+<main class="auth-page"><h1>Sign Up</h1></main>
+`
+  },
+  "db-d1": {
+    "db.ts": `import * as schema from "./db-schema";
+
+export type Database = any;
+
+export function getDb(d1: any): Database {
+  return schema;
+}
+`,
+    "schema.ts": `// Database schema \u2014 define your tables here.
+// See: https://orm.drizzle.team/docs/sql-schema-declaration
+export const users = {};
+`,
+    "drizzle.config.ts": `export default {
+  schema: "./src/lib/db-schema.ts",
+  out: "./drizzle/migrations",
+  dialect: "sqlite",
+} as any;
+`,
+    "migrations/.gitkeep": ""
+  },
+  "blog-mdx": {
+    "schema.ts": `import { z, defineCollection } from "astro:content";
+export const blog = defineCollection({ schema: z.any() });
+`,
+    "pages/index.astro": `---
+---
+<h1>Blog</h1>`,
+    "pages/[slug].astro": `---
+export function getStaticPaths() { return [{ params: { slug: '1' } }]; }
+---
+<h1>Post</h1>`,
+    "pages/rss.xml.ts": `export const GET = () => new Response("RSS");`
+  },
+  "docs-collection": {
+    "schema.ts": `import { z, defineCollection } from "astro:content";
+export const docs = defineCollection({ schema: z.any() });
+`,
+    "pages/[...slug].astro": `---
+export function getStaticPaths() { return [{ params: { slug: '1' } }]; }
+---
+<h1>Docs</h1>`
+  },
+  "layout-marketing": {
+    "layout-marketing.astro": `---
+---
+<slot />`,
+    "default-content.json": `{ "headerLinks": [], "footerText": "" }`
+  },
+  "layout-docs": {
+    "layout-docs.astro": `---
+---
+<slot />`,
+    "default-content.json": `{ "headerTitle": "", "footerText": "" }`
+  },
+  "layout-dashboard": {
+    "layout-dashboard.astro": `---
+---
+<slot />`,
+    "default-content.json": `{ "sidebarLinks": [], "logoutText": "" }`
+  },
+  "hero-video": { "hero-video.astro": "<section>Hero Video</section>\n" },
+  "features-bento": { "features-bento.astro": "<section>Features Bento</section>\n" },
+  "pricing-table": { "pricing-table.astro": "<section>Pricing</section>\n" },
+  "faq-accordion": { "faq-accordion.astro": "<section>FAQ</section>\n" },
+  "footer-rich": { "footer-rich.astro": "<section>Footer</section>\n" },
+  "testimonials-carousel": { "testimonials-carousel.astro": "<section>Testimonials</section>\n" },
+  "contact-form": { "contact-form.astro": "<section>Contact</section>\n" },
+  "hero-split": { "hero-split.astro": "<section>Hero Split</section>\n" },
+  "header-transparent": { "header-transparent.astro": "<header>Transparent</header>\n" },
+  "cta-newsletter": { "cta-newsletter.astro": "<section>CTA</section>\n" },
+  "header-sticky": { "header-sticky.astro": "<header>Sticky</header>\n" }
+};
+var FIXTURE_DEFAULT_CONTENT = {};
+function loadAllPalettes() {
+  try {
+    const registryPath = findRegistryPalettesDir();
+    if (!registryPath) return [];
+    const files = readdirSync(registryPath).filter((f) => f.endsWith(".json"));
+    const palettes = [];
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(registryPath, file), "utf-8");
+        palettes.push(JSON.parse(content));
+      } catch {
+      }
+    }
+    return palettes;
+  } catch {
+    return [];
+  }
+}
+function findRegistryPalettesDir() {
+  try {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    const monorepoRoot = join(thisDir, "..", "..", "..");
+    const palettesDir = join(monorepoRoot, "packages", "fornix-registry", "palettes");
+    readdirSync(palettesDir);
+    return palettesDir;
+  } catch {
+    return null;
+  }
+}
+
+// src/prompts/manual-flow.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+async function runManualFlow(input) {
+  p.intro(pc.bgCyan(pc.black(" Fornix \u2014 Create your project ")));
+  const projectName = await p.text({
+    message: "What is your project name?",
+    placeholder: input.defaultProjectName,
+    defaultValue: input.defaultProjectName,
+    validate(value) {
+      if (!value.trim()) return "Project name is required";
+      if (!/^[a-z0-9-]+$/i.test(value.trim())) {
+        return "Project name must only contain letters, numbers, and dashes";
+      }
+      return void 0;
+    }
+  });
+  if (p.isCancel(projectName)) return handleCancel();
+  const renderMode = await p.select({
+    message: "Choose a render mode",
+    options: [
+      { value: "static", label: "Static (SSG)", hint: "Pre-built HTML, fastest" },
+      { value: "hybrid", label: "Hybrid", hint: "Static by default, opt into SSR per page" },
+      { value: "server", label: "Server (SSR)", hint: "Server-rendered on every request" }
+    ]
+  });
+  if (p.isCancel(renderMode)) return handleCancel();
+  const deployTarget = await p.select({
+    message: "Where will you deploy?",
+    options: [
+      { value: "cloudflare", label: "Cloudflare Pages", hint: "Recommended" },
+      { value: "vercel", label: "Vercel" },
+      { value: "netlify", label: "Netlify" },
+      { value: "static", label: "Static hosting", hint: "No adapter needed" }
+    ]
+  });
+  if (p.isCancel(deployTarget)) return handleCancel();
+  const cssEngine = await p.select({
+    message: "Choose a CSS engine",
+    options: [
+      { value: "tailwind", label: "Tailwind CSS v4", hint: "Recommended" },
+      { value: "vanilla", label: "Vanilla CSS", hint: "No framework" }
+    ]
+  });
+  if (p.isCancel(cssEngine)) return handleCancel();
+  const blockOptions = buildBlockOptions(input.manifests);
+  let selectedBlocks = [];
+  if (blockOptions.length > 0) {
+    const blocks = await p.multiselect({
+      message: "Select blocks to include (space to toggle, enter to confirm)",
+      options: blockOptions,
+      required: false
+    });
+    if (p.isCancel(blocks)) return handleCancel();
+    selectedBlocks = blocks;
+  }
+  const localesInput = await p.text({
+    message: "Locales (comma-separated, e.g. en,es,ar)",
+    placeholder: "en",
+    defaultValue: "en"
+  });
+  if (p.isCancel(localesInput)) return handleCancel();
+  const locales = localesInput.split(",").map((l) => l.trim()).filter(Boolean);
+  const defaultLocale = locales[0] ?? "en";
+  const paletteOptions = buildPaletteOptions(input.allPalettes);
+  let selectedPalette;
+  if (paletteOptions.length > 0) {
+    const paletteChoice = await p.select({
+      message: "Choose a default color palette",
+      options: paletteOptions
+    });
+    if (p.isCancel(paletteChoice)) return handleCancel();
+    selectedPalette = input.allPalettes.find((pal) => pal.name === paletteChoice);
+  }
+  let themeSwitcher = false;
+  if (input.allPalettes.length >= 2) {
+    const paletteCount = input.allPalettes.length;
+    const switcherChoice = await p.confirm({
+      message: `Enable theme switcher? (includes all ${paletteCount} registry palettes for runtime switching)`,
+      initialValue: false
+    });
+    if (p.isCancel(switcherChoice)) return handleCancel();
+    themeSwitcher = switcherChoice;
+  }
+  const config = {
+    projectName: projectName.trim(),
+    projectDir: `./${projectName.trim()}`,
+    renderMode,
+    deployTarget,
+    database: "none",
+    cssEngine,
+    packageManager: "pnpm",
+    blocks: selectedBlocks.map((name) => ({ name, variant: "default" })),
+    locales,
+    defaultLocale,
+    palette: {
+      ...selectedPalette ? { preset: selectedPalette.name } : {},
+      colors: selectedPalette?.colors ?? {
+        primary: "#6366f1",
+        secondary: "#818cf8",
+        accent: "#c084fc",
+        background: "#0f172a",
+        foreground: "#f8fafc"
+      }
+    },
+    themeSwitcher,
+    createdWith: "manual"
+  };
+  p.note(
+    buildSummary(config, selectedBlocks, selectedPalette),
+    "Project Summary"
+  );
+  const confirmed = await p.confirm({
+    message: "Create this project?",
+    initialValue: true
+  });
+  if (p.isCancel(confirmed) || !confirmed) return handleCancel();
+  return config;
+}
+function handleCancel() {
+  p.cancel("Operation cancelled.");
+  return null;
+}
+function buildBlockOptions(manifests) {
+  const blocks = Object.values(manifests);
+  const categories = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    const category = block.category ?? "other";
+    if (!categories.has(category)) {
+      categories.set(category, []);
+    }
+    categories.get(category).push(block);
+  }
+  const options = [];
+  for (const [category, categoryBlocks] of categories) {
+    for (const block of categoryBlocks) {
+      options.push({
+        value: block.name,
+        label: `${block.name}`,
+        hint: `${category} \u2014 ${block.description}`
+      });
+    }
+  }
+  return options;
+}
+function buildPaletteOptions(palettes) {
+  if (palettes.length === 0) return [];
+  const sorted = [...palettes].sort((a, b) => {
+    const catA = a.category ?? "other";
+    const catB = b.category ?? "other";
+    if (catA !== catB) return catA.localeCompare(catB);
+    return a.displayName.localeCompare(b.displayName);
+  });
+  return sorted.map((palette) => {
+    const modeLabel = palette.mode === "dark" ? "\u{1F319}" : "\u2600\uFE0F";
+    const category = palette.category ?? "other";
+    return {
+      value: palette.name,
+      label: `${modeLabel} ${palette.displayName}`,
+      hint: `${category} \xB7 ${palette.colors.primary}`
+    };
+  });
+}
+function buildSummary(config, blockNames, palette) {
+  const lines = [];
+  lines.push(`${pc.bold("Project:")}      ${config.projectName}`);
+  lines.push(`${pc.bold("Render mode:")}  ${config.renderMode}`);
+  lines.push(`${pc.bold("Deploy to:")}    ${config.deployTarget}`);
+  lines.push(`${pc.bold("CSS engine:")}   ${config.cssEngine}`);
+  if (blockNames.length > 0) {
+    lines.push(`${pc.bold("Blocks:")}       ${blockNames.join(", ")}`);
+  } else {
+    lines.push(`${pc.bold("Blocks:")}       ${pc.dim("(none)")}`);
+  }
+  lines.push(`${pc.bold("Locales:")}      ${config.locales.join(", ")} (default: ${config.defaultLocale})`);
+  if (palette) {
+    lines.push(`${pc.bold("Palette:")}      ${palette.displayName} (${palette.mode})`);
+  } else {
+    lines.push(`${pc.bold("Palette:")}      ${pc.dim("default")}`);
+  }
+  if (config.themeSwitcher) {
+    lines.push(`${pc.bold("Theme switcher:")} ${pc.green("yes")} (all registry palettes included)`);
+  } else {
+    lines.push(`${pc.bold("Theme switcher:")} ${pc.dim("no")}`);
+  }
+  return lines.join("\n");
+}
+
+// src/scaffold/post-scaffold.ts
+import { execSync } from "child_process";
+import { writeFileSync } from "fs";
+import { join as join2, basename } from "path";
+import pc2 from "picocolors";
+function runPostScaffold(input, callbacks) {
+  const log = callbacks?.onLog ?? ((msg) => console.log(msg));
+  const warn = callbacks?.onWarn ?? ((msg) => console.warn(msg));
+  const { config, resolvedBlockNames, filesWritten, verbose } = input;
+  const projectDir = config.projectDir;
+  const projectName = basename(projectDir);
+  generateClaudeMd(projectDir, config, resolvedBlockNames);
+  if (verbose) log(pc2.dim("  created CLAUDE.md"));
+  let installSuccess = false;
+  if (!input.skipInstall) {
+    installSuccess = installDependencies(projectDir, config.packageManager, verbose, log, warn);
+  }
+  let gitSuccess = false;
+  if (!input.skipGit) {
+    gitSuccess = initGit(projectDir, verbose, log, warn);
+  }
+  log("");
+  log(pc2.green(pc2.bold("\u2714 Project created successfully!")));
+  log("");
+  log(`  ${pc2.bold("Project:")}  ${config.projectName}`);
+  log(`  ${pc2.bold("Dir:")}      ${projectDir}`);
+  log(`  ${pc2.bold("Render:")}   ${config.renderMode}`);
+  log(`  ${pc2.bold("Deploy:")}   ${config.deployTarget}`);
+  log(`  ${pc2.bold("CSS:")}      ${config.cssEngine}`);
+  if (resolvedBlockNames.length > 0) {
+    log(`  ${pc2.bold("Blocks:")}   ${resolvedBlockNames.join(", ")}`);
+  }
+  if (config.locales.length > 1) {
+    log(`  ${pc2.bold("Locales:")}  ${config.locales.join(", ")} (default: ${config.defaultLocale})`);
+  }
+  if (config.palette.preset) {
+    log(`  ${pc2.bold("Palette:")}  ${config.palette.preset}`);
+  }
+  log(`  ${pc2.bold("Files:")}    ${filesWritten} files written`);
+  if (installSuccess) {
+    log(`  ${pc2.bold("Deps:")}     ${pc2.green("installed")}`);
+  }
+  if (gitSuccess) {
+    log(`  ${pc2.bold("Git:")}      ${pc2.green("initialized")}`);
+  }
+  log("");
+  log(pc2.dim("  Next steps:"));
+  log(pc2.dim(`    cd ${projectName}`));
+  if (!installSuccess) {
+    log(pc2.dim(`    ${config.packageManager} install`));
+  }
+  log(pc2.dim(`    ${config.packageManager} dev`));
+  log(pc2.dim(`    fornix add <block>`));
+  log("");
+}
+function installDependencies(projectDir, packageManager, verbose, log, warn) {
+  try {
+    log(pc2.dim("  Installing dependencies..."));
+    const cmd = `${packageManager} install`;
+    execSync(cmd, {
+      cwd: projectDir,
+      stdio: verbose ? "inherit" : "pipe",
+      timeout: 12e4
+    });
+    return true;
+  } catch {
+    warn(pc2.yellow("  \u26A0 Could not install dependencies automatically."));
+    warn(pc2.dim(`    Run '${packageManager} install' manually.`));
+    return false;
+  }
+}
+function initGit(projectDir, verbose, log, warn) {
+  try {
+    if (verbose) log(pc2.dim("  Initializing git repository..."));
+    execSync("git init", {
+      cwd: projectDir,
+      stdio: "pipe",
+      timeout: 1e4
+    });
+    execSync("git add -A", {
+      cwd: projectDir,
+      stdio: "pipe",
+      timeout: 1e4
+    });
+    execSync('git commit -m "Initial commit \u2014 scaffolded by Fornix"', {
+      cwd: projectDir,
+      stdio: "pipe",
+      timeout: 1e4
+    });
+    return true;
+  } catch {
+    warn(pc2.yellow("  \u26A0 Could not initialize git repository."));
+    warn(pc2.dim("    Run 'git init' manually."));
+    return false;
+  }
+}
+function generateClaudeMd(projectDir, config, blockNames) {
+  const lines = [];
+  lines.push("# CLAUDE.md");
+  lines.push("");
+  lines.push("Project context for AI assistants. Auto-generated by Fornix.");
+  lines.push("");
+  lines.push("## Project Overview");
+  lines.push("");
+  lines.push(`- **Name:** ${config.projectName}`);
+  lines.push(`- **Framework:** Astro`);
+  lines.push(`- **Render mode:** ${config.renderMode}`);
+  lines.push(`- **Deploy target:** ${config.deployTarget}`);
+  lines.push(`- **CSS engine:** ${config.cssEngine}`);
+  lines.push(`- **Package manager:** ${config.packageManager}`);
+  lines.push("");
+  if (blockNames.length > 0) {
+    lines.push("## Installed Blocks");
+    lines.push("");
+    for (const name of blockNames) {
+      const variant = config.blocks.find((b) => b.name === name)?.variant ?? "default";
+      lines.push(`- \`${name}\` (variant: ${variant})`);
+    }
+    lines.push("");
+  }
+  if (config.locales.length > 1) {
+    lines.push("## Internationalization");
+    lines.push("");
+    lines.push(`- **Locales:** ${config.locales.join(", ")}`);
+    lines.push(`- **Default locale:** ${config.defaultLocale}`);
+    lines.push("- Content is organized per locale in `src/content/{locale}/`");
+    lines.push("- Routes are prefixed with `[locale]` parameter");
+    lines.push("");
+  }
+  lines.push("## Styling");
+  lines.push("");
+  if (config.palette.preset) {
+    lines.push(`- **Palette:** ${config.palette.preset}`);
+  }
+  lines.push("- Colors are defined as CSS custom properties in `src/styles/palettes/_current.css`");
+  lines.push("- Use `var(--color-primary)`, `var(--color-secondary)`, etc. for theming");
+  if (config.themeSwitcher) {
+    lines.push("- **Theme switcher** is enabled \u2014 all registry palettes are available at runtime");
+    lines.push("- Palette CSS files are in `src/styles/palettes/`");
+  }
+  lines.push("");
+  lines.push("## Key Commands");
+  lines.push("");
+  lines.push(`- \`${config.packageManager} dev\` \u2014 start development server`);
+  lines.push(`- \`${config.packageManager} build\` \u2014 build for production`);
+  lines.push("- `fornix add <block>` \u2014 add a new block");
+  lines.push("- `fornix remove <block>` \u2014 remove a block");
+  lines.push("- `fornix status` \u2014 show project configuration");
+  lines.push("");
+  lines.push("## File Structure");
+  lines.push("");
+  lines.push("```");
+  lines.push("src/");
+  lines.push("\u251C\u2500\u2500 components/sections/  \u2190 block components");
+  lines.push("\u251C\u2500\u2500 content/              \u2190 JSON/MD content (from blocks)");
+  lines.push("\u251C\u2500\u2500 layouts/              \u2190 page layouts");
+  lines.push("\u251C\u2500\u2500 pages/                \u2190 Astro pages (routes)");
+  lines.push("\u251C\u2500\u2500 styles/               \u2190 CSS and palette files");
+  if (config.renderMode === "server") {
+    lines.push("\u251C\u2500\u2500 middleware/            \u2190 request middleware");
+    lines.push("\u251C\u2500\u2500 lib/                  \u2190 server utilities");
+    lines.push("\u251C\u2500\u2500 pages/api/            \u2190 API endpoints");
+  }
+  if (config.locales.length > 1) {
+    lines.push("\u251C\u2500\u2500 i18n/                 \u2190 translation utilities");
+  }
+  lines.push("```");
+  lines.push("");
+  const content = lines.join("\n");
+  writeFileSync(join2(projectDir, "CLAUDE.md"), content, "utf-8");
+}
+
+// src/ai/prompt-builder.ts
+function buildSystemPrompt(registry) {
+  const sections = [
+    buildIdentity(),
+    buildBlocksCatalog(registry.blocks),
+    buildPalettesCatalog(registry.palettes),
+    buildConstraintRules(registry.blocks),
+    buildOutputInstructions()
+  ];
+  return sections.join("\n\n");
+}
+function buildIdentity() {
+  return `# Fornix AI Assistant
+
+You are the Fornix AI assistant. You analyze user descriptions of websites and produce structured configuration for the Fornix scaffold engine.
+
+Your job:
+1. Understand what the user wants to build
+2. Select appropriate blocks from the available catalog
+3. Choose a palette that fits the brand and industry
+4. Determine the correct render mode, deploy target, and other settings
+5. Generate content for each block's content slots
+
+You MUST only select blocks that exist in the catalog below. Never invent block names.`;
+}
+function buildBlocksCatalog(blocks) {
+  const lines = ["# Available Blocks\n"];
+  const grouped = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (!grouped.has(block.type)) {
+      grouped.set(block.type, []);
+    }
+    grouped.get(block.type).push(block);
+  }
+  for (const [type, typeBlocks] of grouped) {
+    lines.push(`## ${type.toUpperCase()} Blocks
+`);
+    for (const block of typeBlocks) {
+      lines.push(`### ${block.name}`);
+      lines.push(`- **Description:** ${block.description}`);
+      lines.push(`- **Category:** ${block.category}`);
+      lines.push(`- **Tags:** ${block.tags.join(", ") || "none"}`);
+      if (block.ai) {
+        lines.push(`- **When to use:** ${block.ai.whenToUse}`);
+        lines.push(`- **When NOT to use:** ${block.ai.whenNotToUse}`);
+        if (block.ai.pairsWith.length > 0) {
+          lines.push(
+            `- **Pairs with:** ${block.ai.pairsWith.join(", ")}`
+          );
+        }
+        if (block.ai.contentSlots && Object.keys(block.ai.contentSlots).length > 0) {
+          lines.push(`- **Content slots:**`);
+          for (const [slotName, slot] of Object.entries(
+            block.ai.contentSlots
+          )) {
+            const desc = slot.description ? ` \u2014 ${slot.description}` : "";
+            const maxLen = slot.maxLength ? ` (max ${slot.maxLength} chars)` : "";
+            lines.push(`  - \`${slotName}\` (${slot.type})${desc}${maxLen}`);
+          }
+        }
+      }
+      if (block.requires.length > 0) {
+        lines.push(`- **Requires:** ${block.requires.join(", ")}`);
+      }
+      if (block.conflicts.length > 0) {
+        lines.push(`- **Conflicts with:** ${block.conflicts.join(", ")}`);
+      }
+      if (block.requiredMode) {
+        lines.push(`- **Required mode:** ${block.requiredMode}`);
+      }
+      if (Object.keys(block.dependencies).length > 0) {
+        lines.push(
+          `- **npm deps:** ${Object.keys(block.dependencies).join(", ")}`
+        );
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function buildPalettesCatalog(palettes) {
+  const lines = ["# Available Palettes\n"];
+  lines.push(
+    "Select a palette that fits the brand, industry, and visual style.\n"
+  );
+  const grouped = /* @__PURE__ */ new Map();
+  for (const palette of palettes) {
+    if (!grouped.has(palette.category)) {
+      grouped.set(palette.category, []);
+    }
+    grouped.get(palette.category).push(palette);
+  }
+  for (const [category, categoryPalettes] of grouped) {
+    const names = categoryPalettes.map(
+      (p3) => `${p3.displayName} (${p3.mode})`
+    ).join(", ");
+    lines.push(`- **${category}:** ${names}`);
+  }
+  lines.push("");
+  lines.push("Palette names (use these exact values):");
+  for (const palette of palettes) {
+    lines.push(`- \`${palette.name}\` \u2014 ${palette.displayName} (${palette.category}, ${palette.mode})`);
+  }
+  return lines.join("\n");
+}
+function buildConstraintRules(blocks) {
+  const lines = ["# Constraint Rules\n"];
+  lines.push("## Render Modes");
+  lines.push("- `static` \u2014 Pre-rendered HTML, no server. Best for blogs, docs, landing pages.");
+  lines.push("- `hybrid` \u2014 Mix of static + server routes. Best for mostly-static sites with some dynamic features.");
+  lines.push("- `server` \u2014 Full server rendering. Required for auth, databases, real-time features.\n");
+  const serverBlocks = blocks.filter((b) => b.requiredMode === "server");
+  if (serverBlocks.length > 0) {
+    lines.push("## Server-Required Blocks");
+    lines.push(
+      "These blocks REQUIRE `renderMode: 'server'`. Selecting them with static mode is invalid:"
+    );
+    for (const block of serverBlocks) {
+      lines.push(`- \`${block.name}\` (${block.requiredMode})`);
+    }
+    lines.push("");
+  }
+  const blocksWithDeps = blocks.filter((b) => b.requires.length > 0);
+  if (blocksWithDeps.length > 0) {
+    lines.push("## Block Dependencies");
+    lines.push(
+      "These blocks require other blocks to be included:"
+    );
+    for (const block of blocksWithDeps) {
+      lines.push(
+        `- \`${block.name}\` requires: ${block.requires.map((r) => `\`${r}\``).join(", ")}`
+      );
+    }
+    lines.push("");
+  }
+  const blocksWithConflicts = blocks.filter(
+    (b) => b.conflicts.length > 0
+  );
+  if (blocksWithConflicts.length > 0) {
+    lines.push("## Block Conflicts");
+    lines.push(
+      "These blocks cannot be used together:"
+    );
+    for (const block of blocksWithConflicts) {
+      lines.push(
+        `- \`${block.name}\` conflicts with: ${block.conflicts.map((c) => `\`${c}\``).join(", ")}`
+      );
+    }
+    lines.push("");
+  }
+  lines.push("## Deterministic Rules (applied automatically)");
+  lines.push("The following rules are applied by the rules engine BEFORE your output:");
+  lines.push("- Auth or user accounts \u2192 `renderMode: server`, `auth-better-auth` + `db-d1` auto-added");
+  lines.push("- Payments or e-commerce \u2192 upgrade to `hybrid` if static, `payments-stripe` auto-added");
+  lines.push("- Blog with no dynamic content \u2192 `renderMode: static`, `blog-mdx` auto-added");
+  lines.push("- Cloudflare deploy target \u2192 `analytics-cf` auto-added");
+  lines.push("- Multiple languages \u2192 i18n mode enabled, locales set");
+  lines.push("- Theme switcher requested \u2192 `theme-switcher` block auto-added");
+  lines.push("\nDo NOT include auto-added blocks in your recommendations. Focus on section and feature blocks.");
+  return lines.join("\n");
+}
+function buildOutputInstructions() {
+  return `# Output Instructions
+
+Return a structured IntentSchema object with these fields:
+- \`siteType\`: One of: landing-page, saas, agency, portfolio, blog, docs, ecommerce, dashboard, community, other
+- \`industry\`: The industry or niche
+- \`brand\`: { name, tagline?, description, targetAudience?, tone }
+- Boolean signals: needsAuth, needsPayments, needsBlog, needsDocs, needsDashboard, needsContactForm, needsNewsletter, hasDynamicContent, hasEcommerce, hasUserAccounts
+- \`prefersDarkMode\`: Whether the user prefers dark mode
+- \`visualStyle\`: One of: minimal, bold, glassmorphism, gradient, flat, neo-brutalist
+- \`languages\`: Array of language codes (e.g. ['en', 'ar'])
+- \`palettePreference\`: One of: custom, prebuilt, ai-generated, unspecified
+- \`wantsThemeSwitcher\`: Whether the user wants theme switching
+- \`recommendedBlocks\`: Array of { blockName, reason, confidence (0-1) }
+- \`uncertainties\`: Array of { topic, question, defaultAssumption }
+- \`overallConfidence\`: 0-1 score
+
+ONLY recommend blocks that exist in the catalog above. Be precise with block names.`;
+}
+
+// src/ai/schemas.ts
+import { z } from "zod";
+var BrandSchema = z.object({
+  name: z.string().min(1),
+  tagline: z.string().optional(),
+  description: z.string().min(1),
+  targetAudience: z.string().optional(),
+  tone: z.string().min(1)
+});
+var RecommendedBlockSchema = z.object({
+  blockName: z.string().min(1),
+  reason: z.string().min(1),
+  confidence: z.number().min(0).max(1)
+});
+var UncertaintySchema = z.object({
+  topic: z.string().min(1),
+  question: z.string().min(1),
+  defaultAssumption: z.string().min(1)
+});
+var IntentSchema = z.object({
+  siteType: z.enum([
+    "landing-page",
+    "saas",
+    "agency",
+    "portfolio",
+    "blog",
+    "docs",
+    "ecommerce",
+    "dashboard",
+    "community",
+    "other"
+  ]),
+  industry: z.string().min(1),
+  brand: BrandSchema,
+  needsAuth: z.boolean(),
+  needsPayments: z.boolean(),
+  needsBlog: z.boolean(),
+  needsDocs: z.boolean(),
+  needsDashboard: z.boolean(),
+  needsContactForm: z.boolean(),
+  needsNewsletter: z.boolean(),
+  hasDynamicContent: z.boolean(),
+  hasEcommerce: z.boolean(),
+  hasUserAccounts: z.boolean(),
+  prefersDarkMode: z.boolean(),
+  visualStyle: z.enum([
+    "minimal",
+    "bold",
+    "glassmorphism",
+    "gradient",
+    "flat",
+    "neo-brutalist"
+  ]),
+  languages: z.array(z.string().min(1)).default([]),
+  palettePreference: z.enum(["custom", "prebuilt", "ai-generated", "unspecified"]),
+  wantsThemeSwitcher: z.boolean(),
+  recommendedBlocks: z.array(RecommendedBlockSchema),
+  uncertainties: z.array(UncertaintySchema),
+  overallConfidence: z.number().min(0).max(1)
+});
+
+// src/ai/rules.ts
+import { z as z2 } from "zod";
+var IntentSchema2 = z2.object({
+  siteType: z2.enum([
+    "landing-page",
+    "saas",
+    "agency",
+    "portfolio",
+    "blog",
+    "docs",
+    "ecommerce",
+    "dashboard",
+    "community",
+    "other"
+  ]),
+  industry: z2.string(),
+  brand: z2.object({
+    name: z2.string(),
+    tagline: z2.string().optional(),
+    description: z2.string(),
+    targetAudience: z2.string().optional(),
+    tone: z2.string()
+  }),
+  needsAuth: z2.boolean(),
+  needsPayments: z2.boolean(),
+  needsBlog: z2.boolean(),
+  needsDocs: z2.boolean(),
+  needsDashboard: z2.boolean(),
+  needsContactForm: z2.boolean(),
+  needsNewsletter: z2.boolean(),
+  hasDynamicContent: z2.boolean(),
+  hasEcommerce: z2.boolean(),
+  hasUserAccounts: z2.boolean(),
+  prefersDarkMode: z2.boolean(),
+  visualStyle: z2.enum([
+    "minimal",
+    "bold",
+    "glassmorphism",
+    "gradient",
+    "flat",
+    "neo-brutalist"
+  ]),
+  languages: z2.array(z2.string()),
+  palettePreference: z2.enum([
+    "custom",
+    "prebuilt",
+    "ai-generated",
+    "unspecified"
+  ]),
+  wantsThemeSwitcher: z2.boolean(),
+  recommendedBlocks: z2.array(
+    z2.object({
+      blockName: z2.string(),
+      reason: z2.string(),
+      confidence: z2.number()
+    })
+  ),
+  uncertainties: z2.array(
+    z2.object({
+      topic: z2.string(),
+      question: z2.string(),
+      defaultAssumption: z2.string()
+    })
+  ),
+  overallConfidence: z2.number().min(0).max(1)
+});
+function hasBlock(config, name) {
+  return config.blocks.some((b) => b.name === name);
+}
+function addBlock(config, name) {
+  if (!hasBlock(config, name)) {
+    config.blocks.push({ name, variant: "default" });
+  }
+}
+var authRule = {
+  name: "auth",
+  apply(intent, config) {
+    if (intent.needsAuth || intent.hasUserAccounts) {
+      config.renderMode = "server";
+      addBlock(config, "db-d1");
+      addBlock(config, "auth-better-auth");
+    }
+  }
+};
+var paymentsRule = {
+  name: "payments",
+  apply(intent, config) {
+    if (intent.needsPayments || intent.hasEcommerce) {
+      if (config.renderMode === "static") {
+        config.renderMode = "hybrid";
+      }
+      addBlock(config, "payments-stripe");
+    }
+  }
+};
+var blogRule = {
+  name: "blog",
+  apply(intent, config) {
+    if (intent.needsBlog && !intent.hasDynamicContent) {
+      config.renderMode = "static";
+      addBlock(config, "blog-mdx");
+    }
+  }
+};
+var cloudflareAnalyticsRule = {
+  name: "cloudflare-analytics",
+  apply(_intent, config) {
+    if (config.deployTarget === "cloudflare") {
+      addBlock(config, "analytics-cf");
+    }
+  }
+};
+var i18nRule = {
+  name: "i18n",
+  apply(intent, config) {
+    if (intent.languages.length >= 2) {
+      config.locales = [...intent.languages];
+      config.defaultLocale = intent.languages[0];
+    }
+  }
+};
+var themeSwitcherRule = {
+  name: "theme-switcher",
+  apply(intent, config) {
+    if (intent.wantsThemeSwitcher) {
+      config.themeSwitcher = true;
+      addBlock(config, "theme-switcher");
+    }
+  }
+};
+var RULES = [
+  authRule,
+  paymentsRule,
+  blogRule,
+  cloudflareAnalyticsRule,
+  i18nRule,
+  themeSwitcherRule
+];
+function applyRules(intent, config) {
+  for (const rule of RULES) {
+    rule.apply(intent, config);
+  }
+}
+function createDefaultConfig(overrides = {}) {
+  return {
+    renderMode: "static",
+    deployTarget: "cloudflare",
+    database: "none",
+    blocks: [],
+    locales: ["en"],
+    defaultLocale: "en",
+    themeSwitcher: false,
+    ...overrides
+  };
+}
+
+// src/schemas/config.ts
+import { z as z3 } from "zod";
+var BlockSelectionSchema = z3.object({
+  name: z3.string().min(1),
+  variant: z3.string().min(1)
+});
+var PaletteColorsSchema = z3.object({
+  primary: z3.string().min(1),
+  secondary: z3.string().min(1),
+  accent: z3.string().min(1),
+  background: z3.string().min(1),
+  foreground: z3.string().min(1)
+});
+var PaletteConfigSchema = z3.object({
+  preset: z3.string().min(1).optional(),
+  colors: PaletteColorsSchema
+});
+var ResolvedConfigSchema = z3.object({
+  projectName: z3.string().min(1),
+  projectDir: z3.string().min(1),
+  renderMode: z3.enum(["static", "hybrid", "server"]),
+  deployTarget: z3.enum(["cloudflare", "vercel", "netlify", "static"]),
+  database: z3.enum(["none", "d1", "turso", "astro-db", "postgres"]),
+  cssEngine: z3.enum(["tailwind", "vanilla"]),
+  packageManager: z3.enum(["npm", "pnpm", "bun"]),
+  blocks: z3.array(BlockSelectionSchema),
+  locales: z3.array(z3.string().min(1)).transform((locales) => locales.length === 0 ? ["en"] : locales),
+  defaultLocale: z3.string().min(1),
+  palette: PaletteConfigSchema,
+  themeSwitcher: z3.boolean().default(false),
+  content: z3.record(z3.record(z3.unknown())).optional(),
+  createdWith: z3.enum(["ai", "manual", "recipe", "mcp"])
+}).refine(
+  (config) => config.locales.includes(config.defaultLocale),
+  {
+    message: "defaultLocale must be included in the locales array",
+    path: ["defaultLocale"]
+  }
+);
+
+// src/ai/conversation.ts
+var CONFIDENCE_THRESHOLD = 0.8;
+var MAX_CLARIFICATION_ROUNDS = 3;
+var BLOCK_CONFIDENCE_THRESHOLD = 0.7;
+async function runAIConversation(options) {
+  const { provider, registry, description, projectName, projectDir } = options;
+  const intentResult = await analyzeDescription(provider, registry, description);
+  if (!intentResult.ok) {
+    return intentResult;
+  }
+  let intent = intentResult.value;
+  if (options.askQuestion && needsClarification(intent)) {
+    const clarifiedIntent = await runClarificationLoop(
+      provider,
+      registry,
+      intent,
+      description,
+      options.askQuestion
+    );
+    if (!clarifiedIntent.ok) {
+      return clarifiedIntent;
+    }
+    intent = clarifiedIntent.value;
+  }
+  const mutableConfig = intentToMutableConfig(intent);
+  applyRules(intent, mutableConfig);
+  filterBlocksToRegistry(mutableConfig, registry);
+  addRecommendedBlocks(intent, mutableConfig, registry);
+  const palette = selectPalette(intent, registry);
+  const content = generateContent(intent, mutableConfig, registry);
+  return assembleConfig({
+    projectName,
+    projectDir,
+    mutableConfig,
+    palette,
+    content,
+    intent
+  });
+}
+async function analyzeDescription(provider, registry, description) {
+  const systemPrompt = buildSystemPrompt(registry);
+  try {
+    const intent = await provider.generate({
+      system: systemPrompt,
+      prompt: buildAnalysisPrompt(description),
+      schema: IntentSchema
+    });
+    return ok(intent);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown provider error";
+    return err({
+      kind: "ProviderError",
+      message: `Analysis failed: ${message}`,
+      provider: provider.name
+    });
+  }
+}
+function buildAnalysisPrompt(description) {
+  return [
+    "Analyze the following website description and produce a structured IntentSchema.",
+    "",
+    "## User Description",
+    description,
+    "",
+    "## Instructions",
+    "- Extract the site type, industry, and brand information",
+    "- Identify which features are needed (auth, payments, blog, etc.)",
+    "- Detect any language requirements for i18n",
+    "- Recommend appropriate blocks from the catalog",
+    "- Note any uncertainties that need clarification",
+    "- Set overallConfidence based on how well you understand the requirements"
+  ].join("\n");
+}
+function needsClarification(intent) {
+  return intent.overallConfidence < CONFIDENCE_THRESHOLD || intent.uncertainties.length > 0;
+}
+function extractQuestions(intent) {
+  return intent.uncertainties.map((uncertainty, index) => ({
+    id: `uncertainty-${index}`,
+    topic: uncertainty.topic,
+    question: uncertainty.question,
+    defaultAnswer: uncertainty.defaultAssumption
+  }));
+}
+async function runClarificationLoop(provider, registry, intent, originalDescription, askQuestion) {
+  let currentIntent = intent;
+  let round = 0;
+  while (round < MAX_CLARIFICATION_ROUNDS && needsClarification(currentIntent)) {
+    const questions = extractQuestions(currentIntent);
+    if (questions.length === 0) break;
+    const answers = [];
+    for (const question of questions) {
+      const answer = await askQuestion(question);
+      answers.push(answer);
+    }
+    const clarificationContext = buildClarificationPrompt(
+      originalDescription,
+      currentIntent,
+      answers
+    );
+    const reanalysisResult = await analyzeDescription(
+      provider,
+      registry,
+      clarificationContext
+    );
+    if (!reanalysisResult.ok) {
+      return reanalysisResult;
+    }
+    currentIntent = reanalysisResult.value;
+    round++;
+  }
+  return ok(currentIntent);
+}
+function buildClarificationPrompt(originalDescription, intent, answers) {
+  const answerLines = answers.map((answer) => `- ${answer.questionId}: ${answer.value}`).join("\n");
+  return [
+    originalDescription,
+    "",
+    "## Additional Context from Follow-up Questions",
+    answerLines,
+    "",
+    `## Previous Analysis`,
+    `Site type: ${intent.siteType}, Industry: ${intent.industry}`,
+    `Brand: ${intent.brand.name} \u2014 ${intent.brand.description}`,
+    "",
+    "Please refine the analysis with this additional information.",
+    "Increase overallConfidence if the answers resolve previous uncertainties."
+  ].join("\n");
+}
+function intentToMutableConfig(intent) {
+  return createDefaultConfig({
+    locales: intent.languages.length > 0 ? [...intent.languages] : ["en"],
+    defaultLocale: intent.languages.length > 0 ? intent.languages[0] : "en",
+    themeSwitcher: intent.wantsThemeSwitcher
+  });
+}
+function filterBlocksToRegistry(config, registry) {
+  const registryBlockNames = new Set(registry.blocks.map((b) => b.name));
+  config.blocks = config.blocks.filter((b) => registryBlockNames.has(b.name));
+}
+function addRecommendedBlocks(intent, config, registry) {
+  const registryBlockNames = new Set(registry.blocks.map((b) => b.name));
+  for (const recommendation of intent.recommendedBlocks) {
+    if (recommendation.confidence >= BLOCK_CONFIDENCE_THRESHOLD && registryBlockNames.has(recommendation.blockName) && !config.blocks.some((b) => b.name === recommendation.blockName)) {
+      config.blocks.push({
+        name: recommendation.blockName,
+        variant: "default"
+      });
+    }
+  }
+}
+function selectPalette(intent, registry) {
+  const palettes = registry.palettes;
+  if (intent.palettePreference === "prebuilt" && palettes.length > 0) {
+    const matched = findBestPalette(intent, palettes);
+    return {
+      preset: matched.name,
+      colors: { ...matched.colors }
+    };
+  }
+  if (intent.palettePreference === "ai-generated") {
+    const matched = findBestPalette(intent, palettes);
+    return {
+      colors: { ...matched.colors }
+    };
+  }
+  if (palettes.length > 0) {
+    const matched = findBestPalette(intent, palettes);
+    return {
+      preset: matched.name,
+      colors: { ...matched.colors }
+    };
+  }
+  return {
+    colors: {
+      primary: "#3b82f6",
+      secondary: "#6366f1",
+      accent: "#8b5cf6",
+      background: "#ffffff",
+      foreground: "#1a1a2e"
+    }
+  };
+}
+function findBestPalette(intent, palettes) {
+  const modePreference = intent.prefersDarkMode ? "dark" : "light";
+  const modeMatched = palettes.filter((p3) => p3.mode === modePreference);
+  const candidates = modeMatched.length > 0 ? modeMatched : palettes;
+  const industryLower = intent.industry.toLowerCase();
+  const industryMatched = candidates.find(
+    (p3) => p3.name.includes(industryLower) || p3.category.toLowerCase().includes(industryLower)
+  );
+  if (industryMatched) {
+    return industryMatched;
+  }
+  return candidates[0];
+}
+function generateContent(intent, config, registry) {
+  const selectedBlockNames = new Set(config.blocks.map((b) => b.name));
+  const blocksWithContent = registry.blocks.filter(
+    (b) => selectedBlockNames.has(b.name) && b.ai?.contentSlots && Object.keys(b.ai.contentSlots).length > 0
+  );
+  if (blocksWithContent.length === 0) {
+    return void 0;
+  }
+  const content = {};
+  const locales = config.locales;
+  for (const block of blocksWithContent) {
+    const slots = block.ai?.contentSlots;
+    if (!slots) continue;
+    const blockContent = {};
+    for (const locale of locales) {
+      const localeContent = {};
+      for (const [slotName, slot] of Object.entries(slots)) {
+        localeContent[slotName] = generateSlotContent(
+          slotName,
+          slot,
+          intent,
+          locale
+        );
+      }
+      blockContent[locale] = localeContent;
+    }
+    content[block.name] = blockContent;
+  }
+  return Object.keys(content).length > 0 ? content : void 0;
+}
+function generateSlotContent(slotName, slot, intent, locale) {
+  const brandName = intent.brand.name;
+  const localeSuffix = locale !== "en" ? ` (${locale})` : "";
+  switch (slot.type) {
+    case "string": {
+      if (slotName.includes("headline") || slotName.includes("heading") || slotName.includes("title")) {
+        return `${brandName} \u2014 ${intent.brand.tagline ?? intent.brand.description}${localeSuffix}`;
+      }
+      if (slotName.includes("button") || slotName.includes("cta")) {
+        return `Get Started${localeSuffix}`;
+      }
+      if (slotName.includes("copyright")) {
+        return `\xA9 ${(/* @__PURE__ */ new Date()).getFullYear()} ${brandName}. All rights reserved.${localeSuffix}`;
+      }
+      return `${slot.description ?? slotName}${localeSuffix}`;
+    }
+    case "array":
+      return [];
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "object":
+      return {};
+    default:
+      return slot.example ?? null;
+  }
+}
+function assembleConfig(input) {
+  const raw = {
+    projectName: input.projectName,
+    projectDir: input.projectDir,
+    renderMode: input.mutableConfig.renderMode,
+    deployTarget: input.mutableConfig.deployTarget,
+    database: input.mutableConfig.database,
+    cssEngine: "tailwind",
+    packageManager: "pnpm",
+    blocks: input.mutableConfig.blocks.map((b) => ({
+      name: b.name,
+      variant: b.variant
+    })),
+    locales: input.mutableConfig.locales,
+    defaultLocale: input.mutableConfig.defaultLocale,
+    palette: {
+      preset: input.palette.preset,
+      colors: { ...input.palette.colors }
+    },
+    themeSwitcher: input.mutableConfig.themeSwitcher,
+    content: input.content,
+    createdWith: "ai"
+  };
+  const parsed = ResolvedConfigSchema.safeParse(raw);
+  if (!parsed.success) {
+    return err({
+      kind: "ValidationError",
+      message: `Config validation failed: ${parsed.error.message}`,
+      provider: "conversation"
+    });
+  }
+  return ok(parsed.data);
+}
+
+// src/ai/providers/openai-provider.ts
+function createOpenAIProvider(apiKey) {
+  const key = apiKey ?? process.env["OPENAI_API_KEY"];
+  return {
+    name: "openai",
+    async generate(prompt, systemPrompt) {
+      if (!key) {
+        return err({
+          kind: "ProviderError",
+          message: "OPENAI_API_KEY not set. Set it in your environment or pass it explicitly.",
+          prompt
+        });
+      }
+      try {
+        const { generateObject } = await import("ai");
+        const { openai } = await import("@ai-sdk/openai");
+        const result = await generateObject({
+          model: openai("gpt-4o-mini", { structuredOutputs: true }),
+          schema: IntentSchema2,
+          system: systemPrompt ?? "You are the Fornix AI assistant. Analyze the user's website description and produce a structured Intent object.",
+          prompt,
+          maxTokens: 2e3
+        });
+        return ok(result.object);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown OpenAI error";
+        return err({
+          kind: "ProviderError",
+          message: `OpenAI generation failed: ${message}`,
+          prompt
+        });
+      }
+    }
+  };
+}
+
+// src/ai/providers/ollama-provider.ts
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var DEFAULT_MODEL = "llama3.1";
+function createOllamaProvider(opts = {}) {
+  const baseUrl = opts.baseUrl ?? DEFAULT_OLLAMA_URL;
+  const model = opts.model ?? DEFAULT_MODEL;
+  return {
+    name: "ollama",
+    async generate(prompt, systemPrompt) {
+      try {
+        const response = await fetch(`${baseUrl}/api/chat`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            model,
+            stream: false,
+            format: "json",
+            messages: [
+              {
+                role: "system",
+                content: (systemPrompt ?? "You are the Fornix AI assistant.") + "\n\nYou MUST respond with a valid JSON object matching the IntentSchema. Do NOT include any text outside the JSON."
+              },
+              { role: "user", content: prompt }
+            ]
+          })
+        });
+        if (!response.ok) {
+          return err({
+            kind: "ProviderError",
+            message: `Ollama returned status ${response.status}: ${await response.text()}`,
+            prompt
+          });
+        }
+        const data = await response.json();
+        const content = data.message?.content;
+        if (!content) {
+          return err({
+            kind: "ProviderError",
+            message: "Ollama returned empty response",
+            prompt
+          });
+        }
+        const parsed = JSON.parse(content);
+        const validated = IntentSchema2.parse(parsed);
+        return ok(validated);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown Ollama error";
+        return err({
+          kind: "ProviderError",
+          message: `Ollama generation failed: ${message}`,
+          prompt
+        });
+      }
+    }
+  };
+}
+async function isOllamaRunning(baseUrl = DEFAULT_OLLAMA_URL) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e3);
+    const response = await fetch(baseUrl, { signal: controller.signal });
+    clearTimeout(timeout);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/ai/providers/cloudflare-provider.ts
+var DEFAULT_MODEL2 = "@cf/meta/llama-3.1-8b-instruct";
+function createCloudflareProvider(opts = {}) {
+  const accountId = opts.accountId ?? process.env["CLOUDFLARE_ACCOUNT_ID"];
+  const apiToken = opts.apiToken ?? process.env["CLOUDFLARE_API_TOKEN"];
+  const model = opts.model ?? DEFAULT_MODEL2;
+  return {
+    name: "cloudflare",
+    async generate(prompt, systemPrompt) {
+      if (!accountId || !apiToken) {
+        return err({
+          kind: "ProviderError",
+          message: "CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN must be set.",
+          prompt
+        });
+      }
+      try {
+        const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/run/${model}`;
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiToken}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            messages: [
+              {
+                role: "system",
+                content: (systemPrompt ?? "You are the Fornix AI assistant.") + "\n\nRespond with a valid JSON object matching the IntentSchema. No text outside JSON."
+              },
+              { role: "user", content: prompt }
+            ]
+          })
+        });
+        if (!response.ok) {
+          return err({
+            kind: "ProviderError",
+            message: `Cloudflare AI returned status ${response.status}: ${await response.text()}`,
+            prompt
+          });
+        }
+        const data = await response.json();
+        const content = data.result?.response;
+        if (!content) {
+          return err({
+            kind: "ProviderError",
+            message: "Cloudflare AI returned empty response",
+            prompt
+          });
+        }
+        const parsed = JSON.parse(content);
+        const validated = IntentSchema2.parse(parsed);
+        return ok(validated);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown Cloudflare AI error";
+        return err({
+          kind: "ProviderError",
+          message: `Cloudflare AI generation failed: ${message}`,
+          prompt
+        });
+      }
+    }
+  };
+}
+
+// src/ai/providers/mock-provider.ts
+import { readFileSync as readFileSync2, existsSync } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var FIXTURE_ENTRIES = [
+  {
+    keywords: ["fintech", "finance", "banking", "financial"],
+    filename: "fintech-landing.json"
+  },
+  {
+    keywords: ["blog", "personal", "travel", "lifestyle", "writing"],
+    filename: "personal-blog.json"
+  },
+  {
+    keywords: ["saas", "dashboard", "project management", "productivity", "taskflow"],
+    filename: "saas-dashboard.json"
+  },
+  {
+    keywords: ["agency", "multilingual", "design agency", "boutique", "international"],
+    filename: "multilingual-agency.json"
+  },
+  {
+    keywords: ["portfolio", "freelance", "developer", "personal site"],
+    filename: "portfolio.json"
+  }
+];
+function createMockProvider() {
+  return {
+    name: "mock",
+    async generate(prompt) {
+      const lowerPrompt = prompt.toLowerCase();
+      const match = FIXTURE_ENTRIES.find(
+        (entry) => entry.keywords.some((kw) => lowerPrompt.includes(kw))
+      );
+      if (!match) {
+        return err({
+          kind: "ProviderError",
+          message: `No fixture matched for prompt. Keywords tried: ${FIXTURE_ENTRIES.flatMap((e) => e.keywords).join(", ")}`,
+          prompt
+        });
+      }
+      const fixtureDir = resolveFixtureDir();
+      const filePath = join3(fixtureDir, match.filename);
+      try {
+        const raw = readFileSync2(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const validated = IntentSchema2.parse(parsed);
+        return ok(validated);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown parse error";
+        return err({
+          kind: "ProviderError",
+          message: `Failed to load fixture '${match.filename}': ${message}`,
+          prompt
+        });
+      }
+    }
+  };
+}
+function resolveFixtureDir() {
+  const thisDir = dirname2(fileURLToPath2(import.meta.url));
+  const fromSource = join3(thisDir, "..", "..", "..", "tests", "fixtures", "ai-responses");
+  if (existsSync(fromSource)) return fromSource;
+  const fromDist = join3(thisDir, "..", "tests", "fixtures", "ai-responses");
+  if (existsSync(fromDist)) return fromDist;
+  return fromSource;
+}
+
+// src/ai/resolve-provider.ts
+async function resolveProvider(opts = {}) {
+  const env = opts.env ?? process.env;
+  if (opts.provider) {
+    return createProviderByName(opts.provider, env);
+  }
+  if (!opts.skipOllamaDetect) {
+    const ollamaRunning = await isOllamaRunning();
+    if (ollamaRunning) {
+      return createOllamaProvider();
+    }
+  }
+  if (env["OPENAI_API_KEY"]) {
+    return createOpenAIProvider(env["OPENAI_API_KEY"]);
+  }
+  if (env["CLOUDFLARE_ACCOUNT_ID"] && env["CLOUDFLARE_API_TOKEN"]) {
+    return createCloudflareProvider({
+      accountId: env["CLOUDFLARE_ACCOUNT_ID"],
+      apiToken: env["CLOUDFLARE_API_TOKEN"]
+    });
+  }
+  return null;
+}
+function createProviderByName(name, env) {
+  switch (name) {
+    case "openai":
+      return createOpenAIProvider(env["OPENAI_API_KEY"]);
+    case "ollama":
+      return createOllamaProvider();
+    case "cloudflare":
+      return createCloudflareProvider({
+        accountId: env["CLOUDFLARE_ACCOUNT_ID"],
+        apiToken: env["CLOUDFLARE_API_TOKEN"]
+      });
+    case "mock":
+      return createMockProvider();
+  }
+}
+
+// src/cli/recipes.ts
+var RECIPES = {
+  saas: {
+    renderMode: "server",
+    deployTarget: "cloudflare",
+    database: "d1",
+    cssEngine: "tailwind",
+    packageManager: "pnpm",
+    blocks: [
+      { name: "hero-video", variant: "default" },
+      { name: "features-bento", variant: "default" },
+      { name: "pricing-table", variant: "default" },
+      { name: "faq-accordion", variant: "default" },
+      { name: "footer-rich", variant: "default" },
+      { name: "auth-better-auth", variant: "default" },
+      { name: "db-d1", variant: "default" }
+    ],
+    locales: ["en"],
+    defaultLocale: "en",
+    palette: {
+      preset: "obsidian",
+      colors: {
+        primary: "#818cf8",
+        secondary: "#c084fc",
+        accent: "#38bdf8",
+        background: "#0f172a",
+        foreground: "#f8fafc"
+      }
+    },
+    themeSwitcher: false
+  },
+  agency: {
+    renderMode: "static",
+    deployTarget: "cloudflare",
+    database: "none",
+    cssEngine: "tailwind",
+    packageManager: "pnpm",
+    blocks: [
+      { name: "hero-gradient", variant: "default" },
+      { name: "features-grid", variant: "default" },
+      { name: "testimonials-carousel", variant: "default" },
+      { name: "contact-form", variant: "default" },
+      { name: "footer-rich", variant: "default" }
+    ],
+    locales: ["en"],
+    defaultLocale: "en",
+    palette: {
+      preset: "ocean-breeze",
+      colors: {
+        primary: "#0ea5e9",
+        secondary: "#38bdf8",
+        accent: "#7dd3fc",
+        background: "#0c4a6e",
+        foreground: "#f0f9ff"
+      }
+    },
+    themeSwitcher: true
+  },
+  docs: {
+    renderMode: "static",
+    deployTarget: "cloudflare",
+    database: "none",
+    cssEngine: "tailwind",
+    packageManager: "pnpm",
+    blocks: [
+      { name: "header-sticky", variant: "default" },
+      { name: "docs-collection", variant: "default" },
+      { name: "footer-minimal", variant: "default" }
+    ],
+    locales: ["en"],
+    defaultLocale: "en",
+    palette: {
+      preset: "snow",
+      colors: {
+        primary: "#3b82f6",
+        secondary: "#60a5fa",
+        accent: "#93c5fd",
+        background: "#ffffff",
+        foreground: "#0f172a"
+      }
+    },
+    themeSwitcher: false
+  },
+  blog: {
+    renderMode: "static",
+    deployTarget: "cloudflare",
+    database: "none",
+    cssEngine: "tailwind",
+    packageManager: "pnpm",
+    blocks: [
+      { name: "header-transparent", variant: "default" },
+      { name: "hero-split", variant: "default" },
+      { name: "blog-mdx", variant: "default" },
+      { name: "cta-newsletter", variant: "default" },
+      { name: "footer-rich", variant: "default" }
+    ],
+    locales: ["en"],
+    defaultLocale: "en",
+    palette: {
+      preset: "corporate-blue",
+      colors: {
+        primary: "#1d4ed8",
+        secondary: "#2563eb",
+        accent: "#3b82f6",
+        background: "#f8fafc",
+        foreground: "#0f172a"
+      }
+    },
+    themeSwitcher: false
+  },
+  portfolio: {
+    renderMode: "static",
+    deployTarget: "cloudflare",
+    database: "none",
+    cssEngine: "tailwind",
+    packageManager: "pnpm",
+    blocks: [
+      { name: "hero-gradient", variant: "default" },
+      { name: "features-grid", variant: "default" },
+      { name: "contact-form", variant: "default" },
+      { name: "footer-minimal", variant: "default" }
+    ],
+    locales: ["en"],
+    defaultLocale: "en",
+    palette: {
+      preset: "midnight",
+      colors: {
+        primary: "#6366f1",
+        secondary: "#818cf8",
+        accent: "#c084fc",
+        background: "#0f172a",
+        foreground: "#f8fafc"
+      }
+    },
+    themeSwitcher: false
+  }
+};
+
+// src/utils/project-name.ts
+var VALID_NAME_RE = /^[a-z][a-z0-9-]*$/;
+function validateProjectName(name) {
+  if (!name || name.length === 0) {
+    return err("Project name cannot be empty.");
+  }
+  if (!VALID_NAME_RE.test(name)) {
+    const suggestion = suggestProjectName(name);
+    return err(
+      `"${name}" is not a valid project name. Try: "${suggestion}" instead.`
+    );
+  }
+  return ok(name);
+}
+function suggestProjectName(invalid) {
+  let name = invalid.toLowerCase().replace(/[_\s]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-{2,}/g, "-").replace(/^[-.]/, "").replace(/-$/, "");
+  if (!name || name.length === 0 || !/^[a-z]/.test(name)) {
+    return "my-project";
+  }
+  return name;
+}
+
+// src/cli/commands/create.ts
+var DEFAULT_COLORS = {
+  primary: "#6366f1",
+  secondary: "#818cf8",
+  accent: "#c084fc",
+  background: "#0f172a",
+  foreground: "#f8fafc"
+};
+var DEFAULT_AI_DESCRIPTION = "Build a fintech landing page with user authentication and a modern dark theme";
+var VALID_PROVIDER_NAMES = ["openai", "ollama", "cloudflare", "mock"];
+var createCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: "Scaffold a new Fornix project"
+  },
+  args: {
+    dir: {
+      type: "positional",
+      description: "Project directory (defaults to current directory)",
+      required: false
+    },
+    ai: {
+      type: "boolean",
+      description: "AI-assisted mode (default)",
+      default: true
+    },
+    manual: {
+      type: "boolean",
+      description: "Traditional interactive prompts",
+      default: false
+    },
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Accept defaults, non-interactive",
+      default: false
+    },
+    description: {
+      type: "string",
+      description: "Project description for AI mode (used when --yes skips the prompt)"
+    },
+    render: {
+      type: "string",
+      description: "Set render mode: static, hybrid, server"
+    },
+    deploy: {
+      type: "string",
+      description: "Set deploy target: cloudflare, vercel, netlify, static"
+    },
+    blocks: {
+      type: "string",
+      description: "Comma-separated block names"
+    },
+    database: {
+      type: "string",
+      description: "Set database: none, d1, turso, astro-db, postgres"
+    },
+    css: {
+      type: "string",
+      description: "Set CSS engine: tailwind (default) or vanilla"
+    },
+    locales: {
+      type: "string",
+      description: "Comma-separated locale codes (e.g. en,es,ar)"
+    },
+    palette: {
+      type: "string",
+      description: "Use a pre-built palette by name"
+    },
+    "theme-switcher": {
+      type: "boolean",
+      description: "Include the theme switcher for runtime palette swapping",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would be generated without writing",
+      default: false
+    },
+    install: {
+      type: "boolean",
+      description: "Install dependencies after scaffold (use --no-install to skip)",
+      default: true
+    },
+    git: {
+      type: "boolean",
+      description: "Initialize git repo (use --no-git to skip)",
+      default: true
+    },
+    provider: {
+      type: "string",
+      description: "Force a specific AI provider"
+    },
+    recipe: {
+      type: "string",
+      description: "Use a preset recipe (saas, agency, docs)"
+    },
+    verbose: {
+      type: "boolean",
+      description: "Detailed output",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const allPalettes = loadAllPalettes();
+    const hasExplicitFlags = !!(args.render || args.deploy || args.blocks || args.database || args.css || args.locales || args.palette || args.recipe);
+    if (args.manual && !args.yes) {
+      const defaultProjectName = args.dir ? basename2(resolve(args.dir)) : "my-project";
+      const config = await runManualFlow({
+        defaultProjectName,
+        manifests: FIXTURE_MANIFESTS,
+        allPalettes
+      });
+      if (!config) {
+        process.exitCode = 0;
+        return;
+      }
+      const projectDir = args.dir ? resolve(args.dir) : resolve(config.projectDir);
+      const finalConfig = { ...config, projectDir };
+      return runScaffold(finalConfig, allPalettes, args["dry-run"] ?? false, args.verbose ?? false, !(args.install ?? true), !(args.git ?? true));
+    }
+    if (args.manual || hasExplicitFlags) {
+      return runFlagDrivenMode(args, allPalettes);
+    }
+    return runAIMode(args, allPalettes);
+  }
+});
+async function runAIMode(args, allPalettes) {
+  const providerName = parseProviderName(args.provider);
+  if (args.provider && !providerName) {
+    console.error(pc3.red(`\u2716 Unknown provider: ${String(args.provider)}`));
+    console.error(pc3.dim(`  Available: ${VALID_PROVIDER_NAMES.join(", ")}`));
+    process.exitCode = 1;
+    return;
+  }
+  const legacyProvider = await resolveProvider({
+    provider: providerName,
+    skipOllamaDetect: false
+  });
+  if (!legacyProvider) {
+    showNoProviderGuide();
+    process.exitCode = 1;
+    return;
+  }
+  const provider = adaptProvider(legacyProvider);
+  const description = await getDescription(args);
+  if (!description) {
+    process.exitCode = 0;
+    return;
+  }
+  const registry = {
+    blocks: Object.values(FIXTURE_MANIFESTS),
+    palettes: [...allPalettes]
+  };
+  const projectDir = resolve(String(args.dir ?? "."));
+  const projectName = basename2(projectDir);
+  const nameResult = validateProjectName(projectName);
+  if (!nameResult.ok) {
+    console.error(pc3.red(`\u2717 ${nameResult.error}`));
+    process.exitCode = 1;
+    return;
+  }
+  const result = await runAIConversation({
+    provider,
+    registry,
+    description,
+    projectName,
+    projectDir
+  });
+  if (!result.ok) {
+    console.error(pc3.red(`\u2716 AI conversation failed: ${result.error.message}`));
+    process.exitCode = 1;
+    return;
+  }
+  const config = result.value;
+  if (!args.yes) {
+    showAISummary(config);
+    const confirmed = await p2.confirm({
+      message: "Create this project?",
+      initialValue: true
+    });
+    if (p2.isCancel(confirmed) || !confirmed) {
+      p2.cancel("Operation cancelled.");
+      process.exitCode = 0;
+      return;
+    }
+  }
+  return runScaffold(
+    config,
+    allPalettes,
+    (args["dry-run"] ?? false) === true,
+    (args.verbose ?? false) === true,
+    !((args.install ?? true) === true),
+    !((args.git ?? true) === true)
+  );
+}
+function runFlagDrivenMode(args, allPalettes) {
+  const projectDir = resolve(String(args.dir ?? "."));
+  const projectName = basename2(projectDir);
+  const nameResult = validateProjectName(projectName);
+  if (!nameResult.ok) {
+    console.error(pc3.red(`\u2717 ${nameResult.error}`));
+    process.exitCode = 1;
+    return;
+  }
+  const recipeName = args.recipe ? String(args.recipe) : void 0;
+  let recipeOverlay = {};
+  if (recipeName) {
+    if (RECIPES[recipeName]) {
+      recipeOverlay = RECIPES[recipeName];
+      console.log(pc3.green(`\u2714 Using recipe: ${pc3.bold(recipeName)}`));
+    } else {
+      console.error(pc3.red(`\u2716 Recipe "${recipeName}" not found.`));
+      console.error(pc3.dim(`  Available: ${Object.keys(RECIPES).join(", ")}`));
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const renderMode = String(args.render ?? recipeOverlay.renderMode ?? "static");
+  const deployTarget = String(args.deploy ?? recipeOverlay.deployTarget ?? "cloudflare");
+  const database = String(args.database ?? recipeOverlay.database ?? "none");
+  const cssEngine = String(args.css ?? recipeOverlay.cssEngine ?? "tailwind");
+  const localesRaw = String(args.locales ?? "");
+  let locales = ["en"];
+  let defaultLocale = "en";
+  if (localesRaw) {
+    locales = localesRaw.split(",").map((l) => l.trim()).filter(Boolean);
+    defaultLocale = locales[0] ?? "en";
+  } else if (recipeOverlay.locales) {
+    locales = [...recipeOverlay.locales];
+    defaultLocale = recipeOverlay.defaultLocale ?? locales[0] ?? "en";
+  }
+  const themeSwitcher = args["theme-switcher"] !== void 0 ? args["theme-switcher"] === true : recipeOverlay.themeSwitcher ?? false;
+  const blocksString = args.blocks ? String(args.blocks) : "";
+  let blocks = recipeOverlay.blocks ? [...recipeOverlay.blocks] : [];
+  if (blocksString) {
+    const blockNames = blocksString.split(",").map((b) => b.trim()).filter(Boolean);
+    blocks = blockNames.map((name) => ({ name, variant: "default" }));
+  }
+  if (blocks.length === 0) {
+    console.error(pc3.red("\u2717 No blocks selected."));
+    console.error(pc3.dim("  Use --recipe saas for a pre-built set, or drop --manual to let AI choose blocks for you."));
+    process.exitCode = 1;
+    return;
+  }
+  let paletteColors = recipeOverlay.palette ? { ...recipeOverlay.palette.colors } : { ...DEFAULT_COLORS };
+  let palettePreset = recipeOverlay.palette?.preset;
+  if (args.palette) {
+    const paletteName = String(args.palette);
+    const found = allPalettes.find((palette) => palette.name === paletteName);
+    if (found) {
+      paletteColors = { ...found.colors };
+      palettePreset = found.name;
+    } else {
+      console.error(pc3.red(`\u2716 Palette "${paletteName}" not found in registry.`));
+      console.error(pc3.dim(`  Available: ${allPalettes.map((palette) => palette.name).join(", ")}`));
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const config = {
+    projectName,
+    projectDir,
+    renderMode,
+    deployTarget,
+    database,
+    cssEngine,
+    packageManager: "pnpm",
+    blocks,
+    locales,
+    defaultLocale,
+    palette: {
+      ...palettePreset ? { preset: palettePreset } : {},
+      colors: paletteColors
+    },
+    themeSwitcher,
+    createdWith: recipeName ? "recipe" : "manual"
+  };
+  return runScaffold(
+    config,
+    allPalettes,
+    (args["dry-run"] ?? false) === true,
+    (args.verbose ?? false) === true,
+    !((args.install ?? true) === true),
+    !((args.git ?? true) === true)
+  );
+}
+function runScaffold(config, allPalettes, dryRun, verbose, skipInstall, skipGit) {
+  const input = {
+    config,
+    manifests: FIXTURE_MANIFESTS,
+    blockSources: FIXTURE_BLOCK_SOURCES,
+    blockDefaultContent: FIXTURE_DEFAULT_CONTENT,
+    allPalettes
+  };
+  const result = scaffold(input);
+  if (!isOk(result)) {
+    const errMsg = result.error.message;
+    console.error(pc3.red(`\u2717 Scaffold failed: ${errMsg}`));
+    if ("blockA" in result.error && "blockB" in result.error) {
+      const conflict = result.error;
+      console.error(pc3.yellow(`  Block '${conflict.blockA}' conflicts with '${conflict.blockB}'.`));
+      console.error(pc3.dim("  Remove one of these blocks and try again."));
+    }
+    if ("blockName" in result.error) {
+      const notFound = result.error;
+      console.error(pc3.yellow(`  Block '${notFound.blockName}' was not found in the registry.`));
+      console.error(pc3.dim("  If you are offline, cached blocks will be used when available."));
+      console.error(pc3.dim("  Run 'fornix list' to see available blocks."));
+    }
+    process.exitCode = 1;
+    return;
+  }
+  if (dryRun) {
+    console.log(pc3.bold("\n\u{1F4CB} Dry run \u2014 files that would be created:\n"));
+    const sortedFiles = Object.keys(result.value.files).sort();
+    for (const file of sortedFiles) {
+      console.log(pc3.dim("  ") + file);
+    }
+    console.log(pc3.dim(`
+  Total: ${sortedFiles.length} files`));
+    return;
+  }
+  const files = result.value.files;
+  let filesWritten = 0;
+  for (const [relativePath, content] of Object.entries(files)) {
+    const fullPath = join4(config.projectDir, relativePath);
+    const parentDir = join4(fullPath, "..");
+    mkdirSync2(parentDir, { recursive: true });
+    writeFileSync2(fullPath, content, "utf-8");
+    filesWritten++;
+    if (verbose) {
+      console.log(pc3.dim(`  created ${relativePath}`));
+    }
+  }
+  runPostScaffold({
+    config,
+    resolvedBlockNames: result.value.resolvedBlockNames,
+    filesWritten,
+    verbose,
+    skipInstall,
+    skipGit
+  });
+}
+function adaptProvider(legacy) {
+  return {
+    name: legacy.name,
+    async generate(options) {
+      const result = await legacy.generate(options.prompt);
+      if (!result.ok) {
+        throw new Error(result.error.message);
+      }
+      return options.schema.parse(result.value);
+    },
+    async *stream() {
+      yield "";
+    }
+  };
+}
+function parseProviderName(value) {
+  if (!value || typeof value !== "string") return void 0;
+  if (VALID_PROVIDER_NAMES.includes(value)) {
+    return value;
+  }
+  return void 0;
+}
+async function getDescription(args) {
+  if (args.yes) {
+    return typeof args.description === "string" && args.description.length > 0 ? args.description : DEFAULT_AI_DESCRIPTION;
+  }
+  p2.intro(pc3.bgCyan(pc3.black(" Fornix \u2014 AI Mode ")));
+  const input = await p2.text({
+    message: "Describe the website you want to build:",
+    placeholder: "e.g., A fintech landing page with user authentication and a modern dark theme",
+    validate(value) {
+      if (!value.trim()) return "Please describe what you want to build";
+      return void 0;
+    }
+  });
+  if (p2.isCancel(input)) {
+    p2.cancel("Operation cancelled.");
+    return null;
+  }
+  return String(input);
+}
+function showAISummary(config) {
+  const lines = [];
+  lines.push(`${pc3.bold("Project:")}      ${config.projectName}`);
+  lines.push(`${pc3.bold("Render mode:")}  ${config.renderMode}`);
+  lines.push(`${pc3.bold("Deploy to:")}    ${config.deployTarget}`);
+  lines.push(`${pc3.bold("CSS engine:")}   ${config.cssEngine}`);
+  const blockNames = config.blocks.map((b) => b.name);
+  lines.push(`${pc3.bold("Blocks:")}       ${blockNames.length > 0 ? blockNames.join(", ") : pc3.dim("(none)")}`);
+  lines.push(`${pc3.bold("Locales:")}      ${config.locales.join(", ")} (default: ${config.defaultLocale})`);
+  if (config.palette.preset) {
+    lines.push(`${pc3.bold("Palette:")}      ${config.palette.preset}`);
+  }
+  if (config.themeSwitcher) {
+    lines.push(`${pc3.bold("Theme switcher:")} ${pc3.green("yes")}`);
+  }
+  lines.push(`${pc3.bold("Created with:")} ${pc3.cyan("AI")}`);
+  p2.note(lines.join("\n"), "AI-Generated Configuration");
+}
+function showNoProviderGuide() {
+  console.error(pc3.red("\n\u2716 No AI provider found.\n"));
+  console.error("To use AI mode, set up one of the following:\n");
+  console.error(pc3.bold("  Option 1: OpenAI"));
+  console.error("    export OPENAI_API_KEY=sk-...\n");
+  console.error(pc3.bold("  Option 2: Ollama (free, local)"));
+  console.error("    Install from https://ollama.com and run: ollama pull llama3.1\n");
+  console.error(pc3.bold("  Option 3: Cloudflare Workers AI"));
+  console.error("    export CLOUDFLARE_ACCOUNT_ID=... CLOUDFLARE_API_TOKEN=...\n");
+  console.error(pc3.dim("  Or use manual mode: npx create-fornix --manual\n"));
+}
+
+// src/cli/commands/add.ts
+import { defineCommand as defineCommand2 } from "citty";
+import pc4 from "picocolors";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
+var addCommand = defineCommand2({
+  meta: {
+    name: "add",
+    description: "Add a block to an existing Fornix project"
+  },
+  args: {
+    block: {
+      type: "positional",
+      description: "Block name to add (e.g. hero-gradient, auth-better-auth)",
+      required: true
+    },
+    variant: {
+      type: "string",
+      description: "Block variant to use (defaults to 'default')",
+      default: "default"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would change without writing",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      description: "Detailed output",
+      default: false
+    }
+  },
+  run({ args }) {
+    const typedArgs = args;
+    const cwd = process.cwd();
+    const manifestPath = join5(cwd, "fornix.json");
+    if (!existsSync2(manifestPath)) {
+      console.error(
+        pc4.red("\u2717 No fornix.json found. Are you in a Fornix project?")
+      );
+      process.exit(1);
+    }
+    const manifestRaw = readFileSync3(manifestPath, "utf-8");
+    const manifest2 = JSON.parse(manifestRaw);
+    const blockName = typedArgs.block;
+    const blockManifest = FIXTURE_MANIFESTS[blockName];
+    if (!blockManifest) {
+      console.error(pc4.red(`\u2717 Block '${blockName}' not found in registry.`));
+      console.error(
+        pc4.dim(
+          `  Available: ${Object.keys(FIXTURE_MANIFESTS).join(", ")}`
+        )
+      );
+      process.exit(1);
+    }
+    const installedNames = new Set(manifest2.blocks.map((b) => b.name));
+    if (installedNames.has(blockName)) {
+      console.log(
+        pc4.yellow(`\u26A0 Block '${blockName}' is already installed.`)
+      );
+      return;
+    }
+    const blocksToAdd = resolveDependencies2(blockName, installedNames);
+    for (const name of blocksToAdd) {
+      const m = FIXTURE_MANIFESTS[name];
+      if (m?.requiredMode && manifest2.renderMode !== m.requiredMode) {
+        console.error(
+          pc4.red(
+            `\u2717 Block '${name}' requires '${m.requiredMode}' mode, but project uses '${manifest2.renderMode}'.`
+          )
+        );
+        process.exit(1);
+      }
+    }
+    const filesToWrite = [];
+    for (const name of blocksToAdd) {
+      const bManifest = FIXTURE_MANIFESTS[name];
+      const sources = FIXTURE_BLOCK_SOURCES[name];
+      if (!bManifest || !sources) {
+        console.error(pc4.red(`\u2717 Source files not found for block '${name}'.`));
+        process.exit(1);
+      }
+      for (const file of bManifest.files) {
+        const content = sources[file.source];
+        if (content === void 0) {
+          console.error(
+            pc4.red(
+              `\u2717 Source file '${file.source}' not found for block '${name}'.`
+            )
+          );
+          process.exit(1);
+        }
+        filesToWrite.push({
+          path: join5(cwd, file.destination),
+          content
+        });
+      }
+    }
+    if (typedArgs["dry-run"]) {
+      console.log(pc4.bold("\n  Dry run \u2014 no files written\n"));
+      for (const name of blocksToAdd) {
+        const isDep = name !== blockName;
+        console.log(
+          `  ${isDep ? pc4.dim("(dep)") : pc4.green("+")} ${pc4.bold(name)}`
+        );
+      }
+      console.log();
+      for (const file of filesToWrite) {
+        console.log(`  ${pc4.dim("\u2192")} ${file.path}`);
+      }
+      console.log();
+      return;
+    }
+    for (const file of filesToWrite) {
+      mkdirSync3(dirname3(file.path), { recursive: true });
+      writeFileSync3(file.path, file.content);
+      if (typedArgs.verbose) {
+        console.log(`  ${pc4.dim("\u2192")} ${file.path}`);
+      }
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const name of blocksToAdd) {
+      const bManifest = FIXTURE_MANIFESTS[name];
+      if (!bManifest) continue;
+      manifest2.blocks.push({
+        name,
+        version: bManifest.version,
+        variant: name === blockName ? typedArgs.variant : "default",
+        installedAt: now
+      });
+    }
+    writeFileSync3(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
+    console.log();
+    for (const name of blocksToAdd) {
+      const isDep = name !== blockName;
+      if (isDep) {
+        console.log(
+          `  ${pc4.green("+")} ${pc4.bold(name)} ${pc4.dim("(auto-added dependency)")}`
+        );
+      } else {
+        console.log(`  ${pc4.green("+")} ${pc4.bold(name)}`);
+      }
+    }
+    console.log(
+      pc4.dim(
+        `
+  ${filesToWrite.length} files placed, fornix.json updated.`
+      )
+    );
+    console.log();
+  }
+});
+function resolveDependencies2(blockName, installedNames) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  function walk(name) {
+    if (visited.has(name) || installedNames.has(name)) return;
+    visited.add(name);
+    const manifest2 = FIXTURE_MANIFESTS[name];
+    if (!manifest2) return;
+    for (const dep of manifest2.requires) {
+      walk(dep);
+    }
+    result.push(name);
+  }
+  walk(blockName);
+  return result;
+}
+
+// src/cli/commands/remove.ts
+import { defineCommand as defineCommand3 } from "citty";
+import pc5 from "picocolors";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync3, unlinkSync, readdirSync as readdirSync2, rmdirSync } from "fs";
+import { join as join6, dirname as dirname4 } from "path";
+var removeCommand = defineCommand3({
+  meta: {
+    name: "remove",
+    description: "Remove a block from an existing Fornix project"
+  },
+  args: {
+    block: {
+      type: "positional",
+      description: "Block name to remove",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would change without writing",
+      default: false
+    },
+    force: {
+      type: "boolean",
+      description: "Force removal even if other blocks depend on this one",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      description: "Detailed output",
+      default: false
+    }
+  },
+  run({ args }) {
+    const typedArgs = args;
+    const cwd = process.cwd();
+    const manifestPath = join6(cwd, "fornix.json");
+    if (!existsSync3(manifestPath)) {
+      console.error(
+        pc5.red("\u2717 No fornix.json found. Are you in a Fornix project?")
+      );
+      process.exit(1);
+    }
+    const manifestRaw = readFileSync4(manifestPath, "utf-8");
+    const manifest2 = JSON.parse(manifestRaw);
+    const blockName = typedArgs.block;
+    const installedNames = new Set(manifest2.blocks.map((b) => b.name));
+    if (!installedNames.has(blockName)) {
+      console.log(
+        pc5.yellow(`\u26A0 Block '${blockName}' is not installed.`)
+      );
+      return;
+    }
+    const dependents = findDependents(blockName, installedNames);
+    if (dependents.length > 0 && !typedArgs.force) {
+      console.log(
+        pc5.yellow(
+          `\u26A0 Block '${blockName}' is required by: ${dependents.join(", ")}`
+        )
+      );
+      console.log(
+        pc5.dim("  Use --force to remove anyway, or remove dependent blocks first.")
+      );
+      return;
+    }
+    const blockManifest = FIXTURE_MANIFESTS[blockName];
+    const filesToRemove = [];
+    if (blockManifest) {
+      for (const file of blockManifest.files) {
+        const filePath = join6(cwd, file.destination);
+        if (existsSync3(filePath)) {
+          filesToRemove.push(filePath);
+        }
+      }
+    }
+    if (typedArgs["dry-run"]) {
+      console.log(pc5.bold("\n  Dry run \u2014 no files removed\n"));
+      console.log(`  ${pc5.red("-")} ${pc5.bold(blockName)}`);
+      for (const file of filesToRemove) {
+        console.log(`  ${pc5.dim("\xD7")} ${file}`);
+      }
+      console.log();
+      return;
+    }
+    for (const filePath of filesToRemove) {
+      unlinkSync(filePath);
+      if (typedArgs.verbose) {
+        console.log(`  ${pc5.dim("\xD7")} ${filePath}`);
+      }
+      tryRemoveEmptyDir(dirname4(filePath), cwd);
+    }
+    manifest2.blocks = manifest2.blocks.filter((b) => b.name !== blockName);
+    writeFileSync4(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
+    console.log();
+    console.log(`  ${pc5.red("-")} ${pc5.bold(blockName)} removed`);
+    if (dependents.length > 0) {
+      console.log(
+        pc5.yellow(
+          `  \u26A0 Warning: ${dependents.join(", ")} may no longer work correctly.`
+        )
+      );
+    }
+    console.log(
+      pc5.dim(
+        `
+  ${filesToRemove.length} files removed, fornix.json updated.`
+      )
+    );
+    console.log();
+  }
+});
+function findDependents(blockName, installedNames) {
+  const dependents = [];
+  for (const name of installedNames) {
+    const manifest2 = FIXTURE_MANIFESTS[name];
+    if (manifest2 && manifest2.requires.includes(blockName)) {
+      dependents.push(name);
+    }
+  }
+  return dependents;
+}
+function tryRemoveEmptyDir(dirPath, rootPath) {
+  if (dirPath === rootPath || !dirPath.startsWith(rootPath)) return;
+  try {
+    const entries = readdirSync2(dirPath);
+    if (entries.length === 0) {
+      rmdirSync(dirPath);
+      tryRemoveEmptyDir(dirname4(dirPath), rootPath);
+    }
+  } catch {
+  }
+}
+
+// src/cli/commands/list.ts
+import { defineCommand as defineCommand4 } from "citty";
+import pc6 from "picocolors";
+var listCommand = defineCommand4({
+  meta: {
+    name: "list",
+    description: "List available blocks from the Fornix registry"
+  },
+  args: {
+    category: {
+      type: "string",
+      description: "Filter blocks by category"
+    },
+    type: {
+      type: "string",
+      description: "Filter blocks by type (section, integration)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      description: "Show full block details",
+      default: false
+    }
+  },
+  run({ args }) {
+    const typedArgs = args;
+    const blocks = getFilteredBlocks(typedArgs);
+    if (blocks.length === 0) {
+      console.log(pc6.yellow("No blocks found matching your filters."));
+      return;
+    }
+    if (typedArgs.json) {
+      printJson(blocks);
+    } else {
+      printFormatted(blocks, typedArgs.verbose);
+    }
+  }
+});
+function getFilteredBlocks(args) {
+  let blocks = Object.values(FIXTURE_MANIFESTS);
+  if (args.type) {
+    const filterType = args.type.toLowerCase();
+    blocks = blocks.filter((b) => b.type === filterType);
+  }
+  if (args.category) {
+    const filterCategory = args.category.toLowerCase();
+    blocks = blocks.filter((b) => b.category === filterCategory);
+  }
+  return blocks.sort((a, b) => a.name.localeCompare(b.name));
+}
+function printJson(blocks) {
+  const output = blocks.map((b) => ({
+    name: b.name,
+    type: b.type,
+    category: b.category,
+    description: b.description,
+    tags: b.tags,
+    requiredMode: b.requiredMode,
+    requires: b.requires
+  }));
+  console.log(JSON.stringify(output, null, 2));
+}
+function printFormatted(blocks, verbose) {
+  console.log();
+  console.log(
+    pc6.bold(`  \u{1F4E6} Fornix Blocks`) + pc6.dim(` (${blocks.length} available)`)
+  );
+  console.log();
+  const grouped = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    const type = block.type;
+    if (!grouped.has(type)) {
+      grouped.set(type, []);
+    }
+    grouped.get(type).push(block);
+  }
+  const typeIcons = {
+    section: "\u{1F9E9}",
+    integration: "\u2699\uFE0F",
+    feature: "\u2728",
+    layout: "\u{1F4D0}"
+  };
+  for (const [type, typeBlocks] of grouped) {
+    const icon = typeIcons[type] ?? "\u{1F4E6}";
+    console.log(
+      `  ${icon} ${pc6.bold(pc6.cyan(type.toUpperCase()))} ${pc6.dim(`(${typeBlocks.length})`)}`
+    );
+    console.log();
+    for (const block of typeBlocks) {
+      const name = pc6.bold(pc6.white(block.name));
+      const desc = pc6.dim(block.description);
+      const tags = block.tags.map((t) => pc6.dim(`#${t}`)).join(" ");
+      console.log(`    ${name}`);
+      console.log(`    ${desc}`);
+      if (verbose) {
+        console.log(`    ${pc6.dim("Category:")} ${block.category}`);
+        if (block.requiredMode) {
+          console.log(
+            `    ${pc6.dim("Requires:")} ${pc6.yellow(block.requiredMode)} mode`
+          );
+        }
+        if (block.requires.length > 0) {
+          console.log(
+            `    ${pc6.dim("Depends on:")} ${block.requires.join(", ")}`
+          );
+        }
+        if (Object.keys(block.dependencies).length > 0) {
+          const deps = Object.entries(block.dependencies).map(([k, v]) => `${k}@${v}`).join(", ");
+          console.log(`    ${pc6.dim("npm deps:")} ${deps}`);
+        }
+      }
+      console.log(`    ${tags}`);
+      console.log();
+    }
+  }
+}
+
+// src/cli/commands/status.ts
+import { defineCommand as defineCommand5 } from "citty";
+import pc7 from "picocolors";
+import { readFileSync as readFileSync5, existsSync as existsSync4 } from "fs";
+import { join as join7 } from "path";
+var statusCommand = defineCommand5({
+  meta: {
+    name: "status",
+    description: "Show current Fornix project configuration and installed blocks"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      description: "Show full configuration details",
+      default: false
+    }
+  },
+  run({ args }) {
+    const typedArgs = args;
+    const cwd = process.cwd();
+    const manifestPath = join7(cwd, "fornix.json");
+    if (!existsSync4(manifestPath)) {
+      console.error(
+        pc7.red("\u2717 No fornix.json found in the current directory.")
+      );
+      console.error(
+        pc7.dim(
+          "  Run this command from inside a Fornix project, or create one with: npx create-fornix"
+        )
+      );
+      process.exit(1);
+    }
+    let manifest2;
+    try {
+      const raw = readFileSync5(manifestPath, "utf-8");
+      manifest2 = JSON.parse(raw);
+    } catch {
+      console.error(pc7.red("\u2717 Failed to parse fornix.json."));
+      process.exit(1);
+    }
+    if (typedArgs.json) {
+      console.log(JSON.stringify(manifest2, null, 2));
+      return;
+    }
+    printStatus(manifest2, typedArgs.verbose);
+  }
+});
+function printStatus(manifest2, verbose) {
+  console.log();
+  console.log(pc7.bold("  \u{1F4CB} Fornix Project Status"));
+  console.log();
+  console.log(
+    `  ${pc7.dim("Render mode:")}  ${pc7.bold(pc7.cyan(manifest2.renderMode))}`
+  );
+  console.log(
+    `  ${pc7.dim("Deploy target:")} ${pc7.bold(pc7.cyan(manifest2.deployTarget))}`
+  );
+  if (manifest2.palette) {
+    console.log(
+      `  ${pc7.dim("Palette:")}      ${pc7.bold(manifest2.palette)}`
+    );
+  }
+  if (manifest2.locales && manifest2.locales.length > 0) {
+    const localeStr = manifest2.locales.join(", ");
+    const defaultStr = manifest2.defaultLocale ? ` ${pc7.dim(`(default: ${manifest2.defaultLocale})`)}` : "";
+    console.log(
+      `  ${pc7.dim("Locales:")}      ${localeStr}${defaultStr}`
+    );
+  }
+  if (manifest2.database && manifest2.database !== "none") {
+    console.log(
+      `  ${pc7.dim("Database:")}     ${manifest2.database}`
+    );
+  }
+  if (manifest2.themeSwitcher !== void 0) {
+    console.log(
+      `  ${pc7.dim("Theme switcher:")} ${manifest2.themeSwitcher ? "enabled" : "disabled"}`
+    );
+  }
+  if (verbose && manifest2.createdWith) {
+    console.log(
+      `  ${pc7.dim("Created with:")} ${manifest2.createdWith}`
+    );
+    console.log(
+      `  ${pc7.dim("Created at:")}   ${manifest2.createdAt}`
+    );
+  }
+  console.log();
+  console.log(
+    `  ${pc7.bold("Installed blocks")} ${pc7.dim(`(${manifest2.blocks.length})`)}`
+  );
+  console.log();
+  if (manifest2.blocks.length === 0) {
+    console.log(
+      pc7.dim("  No blocks installed. Add one with: fornix add <block>")
+    );
+  } else {
+    for (const block of manifest2.blocks) {
+      const variant = block.variant !== "default" ? pc7.dim(` [${block.variant}]`) : "";
+      console.log(
+        `    ${pc7.green("\u25CF")} ${pc7.bold(block.name)}${variant} ${pc7.dim(`v${block.version}`)}`
+      );
+      if (verbose) {
+        console.log(
+          `      ${pc7.dim("Installed:")} ${block.installedAt}`
+        );
+      }
+    }
+  }
+  console.log();
+}
+
+// src/cli/commands/doctor.ts
+import { defineCommand as defineCommand6 } from "citty";
+import pc8 from "picocolors";
+import { readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
+import { join as join8 } from "path";
+var doctorCommand = defineCommand6({
+  meta: {
+    name: "doctor",
+    description: "Diagnose common issues in a Fornix project"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  run({ args }) {
+    const cwd = process.cwd();
+    const manifestPath = join8(cwd, "fornix.json");
+    let hasErrors = false;
+    const errors = [];
+    function reportError(msg) {
+      hasErrors = true;
+      errors.push(msg);
+      if (!args.json) {
+        console.error(pc8.red(`\u2717 ${msg}`));
+      }
+    }
+    if (!existsSync5(manifestPath)) {
+      reportError("No fornix.json found in the current directory.");
+      if (args.json) {
+        console.log(JSON.stringify({ healthy: false, errors }));
+      }
+      process.exit(1);
+    }
+    let manifest2;
+    try {
+      const raw = readFileSync6(manifestPath, "utf-8");
+      manifest2 = JSON.parse(raw);
+    } catch {
+      reportError("Failed to parse fornix.json.");
+      if (args.json) {
+        console.log(JSON.stringify({ healthy: false, errors }));
+      }
+      process.exit(1);
+    }
+    const isMultiLocale = manifest2.locales && manifest2.locales.length >= 2;
+    const locales = isMultiLocale ? manifest2.locales : [""];
+    const installedBlocks = new Set(manifest2.blocks.map((b) => b.name));
+    for (const block of manifest2.blocks) {
+      const bManifest = FIXTURE_MANIFESTS[block.name];
+      if (bManifest) {
+        for (const file of bManifest.files) {
+          const filePath = join8(cwd, file.destination);
+          if (!existsSync5(filePath)) {
+            reportError(`Missing expected file for installed block '${block.name}': ${file.destination}`);
+          }
+        }
+      }
+    }
+    for (const [name, bManifest] of Object.entries(FIXTURE_MANIFESTS)) {
+      if (!installedBlocks.has(name)) {
+        const foundOrphaned = bManifest.files.some((file) => {
+          return existsSync5(join8(cwd, file.destination));
+        });
+        if (foundOrphaned) {
+          reportError(`Orphaned block files detected for '${name}'. The block is not in fornix.json.`);
+        }
+      }
+    }
+    let requiresContentConfig = false;
+    const missingContentFiles = [];
+    for (const block of manifest2.blocks) {
+      const bManifest = FIXTURE_MANIFESTS[block.name];
+      if (!bManifest) continue;
+      const hasContentSlots = bManifest.ai?.contentSlots && Object.keys(bManifest.ai.contentSlots).length > 0;
+      const hasCollections = bManifest.collections && bManifest.collections.length > 0;
+      if (hasContentSlots || hasCollections) {
+        requiresContentConfig = true;
+      }
+      if (hasContentSlots) {
+        const subdirectory = getCategory(bManifest.type);
+        for (const locale of locales) {
+          let pathFragment = `src/content/${subdirectory}/${bManifest.name}.json`;
+          if (locale !== "") {
+            pathFragment = `src/content/${locale}/${subdirectory}/${bManifest.name}.json`;
+          }
+          if (!existsSync5(join8(cwd, pathFragment))) {
+            missingContentFiles.push(pathFragment);
+          }
+        }
+      }
+    }
+    if (requiresContentConfig) {
+      if (!existsSync5(join8(cwd, "src/content/config.ts"))) {
+        reportError("Missing expected file: src/content/config.ts");
+      }
+    }
+    for (const missing of missingContentFiles) {
+      reportError(`Broken content reference: missing ${missing}`);
+    }
+    if (hasErrors) {
+      if (args.json) {
+        console.log(JSON.stringify({ healthy: false, errors }));
+      } else {
+        console.log();
+        console.log(pc8.yellow("Run 'fornix add <block>' to repair missing blocks or 'fornix remove <block>' to clean orphaned files."));
+      }
+      process.exit(1);
+    } else {
+      if (args.json) {
+        console.log(JSON.stringify({ healthy: true, errors: [] }));
+      } else {
+        console.log(pc8.green("\u2713 Project is healthy!"));
+      }
+    }
+  }
+});
+function getCategory(type) {
+  switch (type) {
+    case "section":
+      return "sections";
+    case "integration":
+      return "integrations";
+    case "feature":
+      return "features";
+    case "layout":
+      return "layouts";
+    default:
+      return type;
+  }
+}
+
+// src/cli/commands/mcp.ts
+import { defineCommand as defineCommand7 } from "citty";
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/mcp/tools/list-blocks.ts
+function listBlocks(input) {
+  let blocks = Object.values(FIXTURE_MANIFESTS);
+  if (input.type) {
+    const filterType = input.type.toLowerCase();
+    blocks = blocks.filter((block) => block.type === filterType);
+  }
+  if (input.category) {
+    const filterCategory = input.category.toLowerCase();
+    blocks = blocks.filter((block) => block.category === filterCategory);
+  }
+  if (input.search) {
+    const searchTerm = input.search.toLowerCase();
+    blocks = blocks.filter(
+      (block) => block.name.includes(searchTerm) || block.description.toLowerCase().includes(searchTerm) || block.tags.some((tag) => tag.includes(searchTerm))
+    );
+  }
+  const entries = blocks.map((block) => ({
+    name: block.name,
+    type: block.type,
+    category: block.category,
+    description: block.description,
+    tags: block.tags,
+    requiredMode: block.requiredMode,
+    requires: block.requires
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  return ok(entries);
+}
+
+// src/mcp/tools/add-block.ts
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { join as join9, dirname as dirname5 } from "path";
+function addBlock2(input) {
+  const { name, variant = "default", projectDirectory } = input;
+  const manifestPath = join9(projectDirectory, "fornix.json");
+  if (!existsSync6(manifestPath)) {
+    return err(
+      new Error("No fornix.json found. Not a Fornix project directory.")
+    );
+  }
+  let manifest2;
+  try {
+    const raw = readFileSync7(manifestPath, "utf-8");
+    manifest2 = JSON.parse(raw);
+  } catch {
+    return err(new Error("Failed to parse fornix.json."));
+  }
+  const blockManifest = FIXTURE_MANIFESTS[name];
+  if (!blockManifest) {
+    return err(
+      new Error(
+        `Block '${name}' not found in registry. Available: ${Object.keys(FIXTURE_MANIFESTS).join(", ")}`
+      )
+    );
+  }
+  const installedNames = new Set(manifest2.blocks.map((block) => block.name));
+  if (installedNames.has(name)) {
+    return ok({ addedBlocks: [], filesCreated: 0 });
+  }
+  const blocksToAdd = resolveDependencies3(name, installedNames);
+  for (const blockName of blocksToAdd) {
+    const dependencyManifest = FIXTURE_MANIFESTS[blockName];
+    if (dependencyManifest?.requiredMode && manifest2.renderMode !== dependencyManifest.requiredMode) {
+      return err(
+        new Error(
+          `Block '${blockName}' requires '${dependencyManifest.requiredMode}' mode, but project uses '${manifest2.renderMode}'.`
+        )
+      );
+    }
+  }
+  let filesCreated = 0;
+  for (const blockName of blocksToAdd) {
+    const blockDef = FIXTURE_MANIFESTS[blockName];
+    const sources = FIXTURE_BLOCK_SOURCES[blockName];
+    if (!blockDef || !sources) {
+      return err(
+        new Error(`Source files not found for block '${blockName}'.`)
+      );
+    }
+    for (const file of blockDef.files) {
+      const content = sources[file.source];
+      if (content === void 0) {
+        return err(
+          new Error(
+            `Source file '${file.source}' not found for block '${blockName}'.`
+          )
+        );
+      }
+      const filePath = join9(projectDirectory, file.destination);
+      mkdirSync4(dirname5(filePath), { recursive: true });
+      writeFileSync5(filePath, content);
+      filesCreated++;
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const blockName of blocksToAdd) {
+    const blockDef = FIXTURE_MANIFESTS[blockName];
+    if (!blockDef) continue;
+    manifest2.blocks.push({
+      name: blockName,
+      version: blockDef.version,
+      variant: blockName === name ? variant : "default",
+      installedAt: now
+    });
+  }
+  writeFileSync5(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
+  return ok({ addedBlocks: blocksToAdd, filesCreated });
+}
+function resolveDependencies3(blockName, installedNames) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  function walk(currentName) {
+    if (visited.has(currentName) || installedNames.has(currentName)) return;
+    visited.add(currentName);
+    const manifest2 = FIXTURE_MANIFESTS[currentName];
+    if (!manifest2) return;
+    for (const dependency of manifest2.requires) {
+      walk(dependency);
+    }
+    result.push(currentName);
+  }
+  walk(blockName);
+  return result;
+}
+
+// src/mcp/tools/remove-block.ts
+import {
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync6,
+  existsSync as existsSync7,
+  unlinkSync as unlinkSync2,
+  readdirSync as readdirSync3,
+  rmdirSync as rmdirSync2
+} from "fs";
+import { join as join10, dirname as dirname6 } from "path";
+function removeBlock(input) {
+  const { name, force = false, projectDirectory } = input;
+  const manifestPath = join10(projectDirectory, "fornix.json");
+  if (!existsSync7(manifestPath)) {
+    return err(
+      new Error("No fornix.json found. Not a Fornix project directory.")
+    );
+  }
+  let manifest2;
+  try {
+    const raw = readFileSync8(manifestPath, "utf-8");
+    manifest2 = JSON.parse(raw);
+  } catch {
+    return err(new Error("Failed to parse fornix.json."));
+  }
+  const installedNames = new Set(manifest2.blocks.map((block) => block.name));
+  if (!installedNames.has(name)) {
+    return err(new Error(`Block '${name}' is not installed.`));
+  }
+  const dependents = findDependents2(name, installedNames);
+  if (dependents.length > 0 && !force) {
+    return err(
+      new Error(
+        `Block '${name}' is required by: ${dependents.join(", ")}. Use force to remove anyway.`
+      )
+    );
+  }
+  const blockManifest = FIXTURE_MANIFESTS[name];
+  const filesToRemove = [];
+  if (blockManifest) {
+    for (const file of blockManifest.files) {
+      const filePath = join10(projectDirectory, file.destination);
+      if (existsSync7(filePath)) {
+        filesToRemove.push(filePath);
+      }
+    }
+  }
+  for (const filePath of filesToRemove) {
+    unlinkSync2(filePath);
+    tryRemoveEmptyDirectory(dirname6(filePath), projectDirectory);
+  }
+  manifest2.blocks = manifest2.blocks.filter((block) => block.name !== name);
+  writeFileSync6(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
+  return ok({
+    removedBlock: name,
+    filesRemoved: filesToRemove.length,
+    dependentsWarning: dependents
+  });
+}
+function findDependents2(blockName, installedNames) {
+  const dependents = [];
+  for (const installedName of installedNames) {
+    const manifest2 = FIXTURE_MANIFESTS[installedName];
+    if (manifest2 && manifest2.requires.includes(blockName)) {
+      dependents.push(installedName);
+    }
+  }
+  return dependents;
+}
+function tryRemoveEmptyDirectory(directoryPath, rootPath) {
+  if (directoryPath === rootPath || !directoryPath.startsWith(rootPath)) return;
+  try {
+    const entries = readdirSync3(directoryPath);
+    if (entries.length === 0) {
+      rmdirSync2(directoryPath);
+      tryRemoveEmptyDirectory(dirname6(directoryPath), rootPath);
+    }
+  } catch {
+  }
+}
+
+// src/mcp/tools/get-content-schema.ts
+function getContentSchema(input) {
+  const { collection } = input;
+  const manifest2 = FIXTURE_MANIFESTS[collection];
+  if (!manifest2) {
+    return err(
+      new Error(`Collection '${collection}' not found in registry.`)
+    );
+  }
+  const contentSlots = manifest2.ai?.contentSlots;
+  if (!contentSlots || Object.keys(contentSlots).length === 0) {
+    return err(
+      new Error(
+        `Block '${collection}' does not define content slots.`
+      )
+    );
+  }
+  return ok({
+    collection,
+    slots: contentSlots
+  });
+}
+
+// src/mcp/tools/validate-content.ts
+import { z as z4 } from "zod";
+function validateContent(input) {
+  const { collection, data } = input;
+  const manifest2 = FIXTURE_MANIFESTS[collection];
+  if (!manifest2) {
+    return err(
+      new Error(
+        `Collection '${collection}' not found in registry.`
+      )
+    );
+  }
+  const contentSlots = manifest2.ai?.contentSlots;
+  if (!contentSlots || Object.keys(contentSlots).length === 0) {
+    return err(
+      new Error(
+        `Block '${collection}' does not define content slots.`
+      )
+    );
+  }
+  const schemaShape = {};
+  for (const [slotName, slot] of Object.entries(contentSlots)) {
+    schemaShape[slotName] = zodTypeForSlot2(slot.type);
+  }
+  const schema = z4.object(schemaShape);
+  const parseResult = schema.safeParse(data);
+  if (parseResult.success) {
+    return ok({ valid: true, errors: [] });
+  }
+  const errors = parseResult.error.issues.map(
+    (issue) => `${issue.path.join(".")}: ${issue.message}`
+  );
+  return ok({ valid: false, errors });
+}
+function zodTypeForSlot2(slotType) {
+  switch (slotType) {
+    case "string":
+      return z4.string();
+    case "number":
+      return z4.number();
+    case "boolean":
+      return z4.boolean();
+    case "array":
+      return z4.array(z4.unknown());
+    case "object":
+      return z4.record(z4.unknown());
+    default:
+      return z4.unknown();
+  }
+}
+
+// src/mcp/tools/get-project-status.ts
+import { readFileSync as readFileSync9, existsSync as existsSync8 } from "fs";
+import { join as join11 } from "path";
+function getProjectStatus(input) {
+  const manifestPath = join11(input.projectDirectory, "fornix.json");
+  if (!existsSync8(manifestPath)) {
+    return err(
+      new Error("No fornix.json found. Not a Fornix project directory.")
+    );
+  }
+  try {
+    const raw = readFileSync9(manifestPath, "utf-8");
+    const manifest2 = JSON.parse(raw);
+    const blocks = manifest2.blocks;
+    return ok({
+      version: manifest2.version,
+      createdAt: manifest2.createdAt,
+      createdWith: manifest2.createdWith,
+      renderMode: manifest2.renderMode,
+      deployTarget: manifest2.deployTarget,
+      database: manifest2.database ?? "none",
+      locales: manifest2.locales ?? ["en"],
+      defaultLocale: manifest2.defaultLocale ?? "en",
+      palette: manifest2.palette,
+      themeSwitcher: manifest2.themeSwitcher ?? false,
+      blocks: blocks ?? []
+    });
+  } catch {
+    return err(new Error("Failed to parse fornix.json."));
+  }
+}
+
+// src/mcp/tools/scaffold-project.ts
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync7 } from "fs";
+import { join as join12, basename as basename3 } from "path";
+var DEFAULT_COLORS2 = {
+  primary: "#6366f1",
+  secondary: "#818cf8",
+  accent: "#c084fc",
+  background: "#0f172a",
+  foreground: "#f8fafc"
+};
+function scaffoldProject(input) {
+  const {
+    projectDirectory,
+    renderMode = "static",
+    deployTarget = "cloudflare",
+    blocks = [],
+    locales = ["en"]
+  } = input;
+  const projectName = basename3(projectDirectory);
+  const blockSelections = blocks.map((name) => ({ name, variant: "default" }));
+  const allPalettes = loadAllPalettes();
+  const config = {
+    projectName,
+    projectDir: projectDirectory,
+    renderMode,
+    deployTarget,
+    database: "none",
+    cssEngine: "tailwind",
+    packageManager: "pnpm",
+    blocks: blockSelections,
+    locales: locales.length > 0 ? [...locales] : ["en"],
+    defaultLocale: locales[0] ?? "en",
+    palette: {
+      colors: { ...DEFAULT_COLORS2 }
+    },
+    themeSwitcher: false,
+    createdWith: "mcp"
+  };
+  const scaffoldInput = {
+    config,
+    manifests: FIXTURE_MANIFESTS,
+    blockSources: FIXTURE_BLOCK_SOURCES,
+    blockDefaultContent: FIXTURE_DEFAULT_CONTENT,
+    allPalettes
+  };
+  const result = scaffold(scaffoldInput);
+  if (!isOk(result)) {
+    return err(result.error);
+  }
+  const files = result.value.files;
+  let filesCreated = 0;
+  for (const [relativePath, content] of Object.entries(files)) {
+    const fullPath = join12(projectDirectory, relativePath);
+    const parentDirectory = join12(fullPath, "..");
+    mkdirSync5(parentDirectory, { recursive: true });
+    writeFileSync7(fullPath, content, "utf-8");
+    filesCreated++;
+  }
+  return ok({
+    projectDirectory,
+    filesCreated,
+    blocks: result.value.resolvedBlockNames
+  });
+}
+
+// src/mcp/server.ts
+var TOOL_DEFINITIONS = [
+  {
+    name: "list_blocks",
+    description: "List available blocks from the Fornix registry",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: { type: "string", description: "Filter by block type (section, integration, feature, layout)" },
+        category: { type: "string", description: "Filter by category" },
+        search: { type: "string", description: "Search term to filter blocks" }
+      }
+    }
+  },
+  {
+    name: "add_block",
+    description: "Add a block to an existing Fornix project",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Block name to add" },
+        variant: { type: "string", description: "Block variant (default: 'default')" },
+        projectDirectory: { type: "string", description: "Path to the Fornix project directory" }
+      },
+      required: ["name", "projectDirectory"]
+    }
+  },
+  {
+    name: "remove_block",
+    description: "Remove a block from an existing Fornix project",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Block name to remove" },
+        force: { type: "boolean", description: "Force removal even if other blocks depend on it" },
+        projectDirectory: { type: "string", description: "Path to the Fornix project directory" }
+      },
+      required: ["name", "projectDirectory"]
+    }
+  },
+  {
+    name: "get_content_schema",
+    description: "Get the content slot schema for a block collection",
+    inputSchema: {
+      type: "object",
+      properties: {
+        collection: { type: "string", description: "Block/collection name" }
+      },
+      required: ["collection"]
+    }
+  },
+  {
+    name: "update_content",
+    description: "Modify content entries for a block collection",
+    inputSchema: {
+      type: "object",
+      properties: {
+        collection: { type: "string", description: "Block/collection name" },
+        entry: { type: "string", description: "Entry identifier" },
+        data: { type: "object", description: "Content data to set" }
+      },
+      required: ["collection", "data"]
+    }
+  },
+  {
+    name: "validate_content",
+    description: "Validate content data against a block's content schema",
+    inputSchema: {
+      type: "object",
+      properties: {
+        collection: { type: "string", description: "Block/collection name" },
+        data: { type: "object", description: "Content data to validate" }
+      },
+      required: ["collection", "data"]
+    }
+  },
+  {
+    name: "get_project_status",
+    description: "Get the current Fornix project configuration and installed blocks",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectDirectory: { type: "string", description: "Path to the Fornix project directory" }
+      },
+      required: ["projectDirectory"]
+    }
+  },
+  {
+    name: "scaffold_project",
+    description: "Scaffold a complete Fornix project from a natural language description",
+    inputSchema: {
+      type: "object",
+      properties: {
+        description: { type: "string", description: "Natural language description of the project" },
+        projectDirectory: { type: "string", description: "Path to create the project in" },
+        renderMode: { type: "string", description: "Render mode: static, hybrid, server" },
+        deployTarget: { type: "string", description: "Deploy target: cloudflare, vercel, netlify, static" },
+        blocks: { type: "array", items: { type: "string" }, description: "Block names to include" },
+        locales: { type: "array", items: { type: "string" }, description: "Locale codes" }
+      },
+      required: ["description", "projectDirectory"]
+    }
+  }
+];
+var FornixMCPServer = class {
+  server;
+  registeredTools = [];
+  registeredResources = [];
+  constructor() {
+    this.server = new Server(
+      {
+        name: "fornix-mcp",
+        version: "0.0.1"
+      },
+      {
+        capabilities: {
+          resources: {},
+          tools: {}
+        }
+      }
+    );
+    this.registerTools();
+    this.registerResources();
+    this.setupHandlers();
+  }
+  registerTools() {
+    this.registeredTools = TOOL_DEFINITIONS.map(
+      (definition) => definition.name
+    );
+  }
+  registerResources() {
+    this.registeredResources = [
+      "fornix://registry",
+      "fornix://project/config"
+    ];
+  }
+  setupHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: TOOL_DEFINITIONS.map((definition) => ({
+          name: definition.name,
+          description: definition.description,
+          inputSchema: definition.inputSchema
+        }))
+      };
+    });
+    this.server.setRequestHandler(
+      CallToolRequestSchema,
+      async (request) => {
+        const toolName = request.params.name;
+        const args = request.params.arguments ?? {};
+        const result = await this.executeTool(toolName, args);
+        if (!result.ok) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ error: result.error.message })
+              }
+            ],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.value
+            }
+          ]
+        };
+      }
+    );
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      return {
+        resources: this.registeredResources.map((uri) => ({
+          uri,
+          name: uri,
+          description: `Fornix MCP Resource: ${uri}`
+        }))
+      };
+    });
+    this.server.setRequestHandler(
+      ReadResourceRequestSchema,
+      async (request) => {
+        const uri = request.params.uri;
+        if (uri === "fornix://registry") {
+          const blocks = Object.values(FIXTURE_MANIFESTS).map((manifest2) => ({
+            name: manifest2.name,
+            type: manifest2.type,
+            category: manifest2.category,
+            description: manifest2.description
+          }));
+          return {
+            contents: [
+              {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify(blocks, null, 2)
+              }
+            ]
+          };
+        }
+        if (uri === "fornix://project/config") {
+          return {
+            contents: [
+              {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify({
+                  message: "Use get_project_status tool with a projectDirectory to read project config."
+                })
+              }
+            ]
+          };
+        }
+        throw new Error(`Unknown resource: ${uri}`);
+      }
+    );
+  }
+  /**
+   * Execute a tool by name with the given arguments.
+   * Exposed as a public method for testing without MCP transport.
+   */
+  async callTool(toolName, args) {
+    return this.executeTool(toolName, args);
+  }
+  async executeTool(toolName, args) {
+    switch (toolName) {
+      case "list_blocks": {
+        const result = listBlocks({
+          type: args.type,
+          category: args.category,
+          search: args.search
+        });
+        if (!result.ok) return err(result.error);
+        return ok(JSON.stringify(result.value, null, 2));
+      }
+      case "add_block": {
+        const result = addBlock2({
+          name: args.name,
+          variant: args.variant,
+          projectDirectory: args.projectDirectory
+        });
+        if (!result.ok) return err(result.error);
+        return ok(JSON.stringify(result.value, null, 2));
+      }
+      case "remove_block": {
+        const result = removeBlock({
+          name: args.name,
+          force: args.force,
+          projectDirectory: args.projectDirectory
+        });
+        if (!result.ok) return err(result.error);
+        return ok(JSON.stringify(result.value, null, 2));
+      }
+      case "get_content_schema": {
+        const result = getContentSchema({
+          collection: args.collection
+        });
+        if (!result.ok) return err(result.error);
+        return ok(JSON.stringify(result.value, null, 2));
+      }
+      case "update_content": {
+        const validationResult = validateContent({
+          collection: args.collection,
+          data: args.data
+        });
+        if (!validationResult.ok) return err(validationResult.error);
+        if (!validationResult.value.valid) {
+          return ok(
+            JSON.stringify({
+              updated: false,
+              errors: validationResult.value.errors
+            })
+          );
+        }
+        return ok(
+          JSON.stringify({
+            updated: true,
+            collection: args.collection,
+            data: args.data
+          })
+        );
+      }
+      case "validate_content": {
+        const result = validateContent({
+          collection: args.collection,
+          data: args.data
+        });
+        if (!result.ok) return err(result.error);
+        return ok(JSON.stringify(result.value, null, 2));
+      }
+      case "get_project_status": {
+        const result = getProjectStatus({
+          projectDirectory: args.projectDirectory
+        });
+        if (!result.ok) return err(result.error);
+        return ok(JSON.stringify(result.value, null, 2));
+      }
+      case "scaffold_project": {
+        const result = scaffoldProject({
+          description: args.description,
+          projectDirectory: args.projectDirectory,
+          renderMode: args.renderMode,
+          deployTarget: args.deployTarget,
+          blocks: args.blocks,
+          locales: args.locales
+        });
+        if (!result.ok) return err(result.error);
+        return ok(JSON.stringify(result.value, null, 2));
+      }
+      default:
+        return err(new Error(`Unknown tool: ${toolName}`));
+    }
+  }
+  // Exposed for TDD checks
+  getRegisteredTools() {
+    return this.registeredTools;
+  }
+  getRegisteredResources() {
+    return this.registeredResources;
+  }
+  async start() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+  }
+};
+
+// src/cli/commands/mcp.ts
+var serveCommand = defineCommand7({
+  meta: {
+    name: "serve",
+    description: "Start the Fornix MCP Server over stdio"
+  },
+  async run() {
+    console.error("Starting Fornix MCP Server...");
+    const mcpServer = new FornixMCPServer();
+    await mcpServer.start();
+    console.error("Fornix MCP Server running on stdio.");
+  }
+});
+var mcpCommand = defineCommand7({
+  meta: {
+    name: "mcp",
+    description: "Manage and run the Model Context Protocol (MCP) server"
+  },
+  subCommands: {
+    serve: serveCommand
+  }
+});
+
+// src/cli/index.ts
+var main = defineCommand8({
+  meta: {
+    name: "fornix",
+    version: "0.0.1",
+    description: "Fornix \u2014 CLI-first Astro + Cloudflare project generator"
+  },
+  subCommands: {
+    create: createCommand,
+    add: addCommand,
+    remove: removeCommand,
+    list: listCommand,
+    status: statusCommand,
+    doctor: doctorCommand,
+    mcp: mcpCommand
+  }
+});
+
+// src/index.ts
+runMain(main);
+//# sourceMappingURL=index.js.map