@collie-lang/cli 1.1.1 → 1.3.0

package/dist/index.cjs

@@ -1,2588 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/index.ts
-var import_node_child_process2 = require("child_process");
-var import_promises9 = __toESM(require("fs/promises"), 1);
-var import_node_fs4 = require("fs");
-var import_node_path9 = __toESM(require("path"), 1);
-var import_node_url2 = require("url");
-var import_typescript = __toESM(require("typescript"), 1);
-var import_fast_glob4 = __toESM(require("fast-glob"), 1);
-var import_diff = require("diff");
-var import_picocolors8 = __toESM(require("picocolors"), 1);
-var import_prompts2 = __toESM(require("prompts"), 1);
-
-// src/formatter.ts
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_compiler = require("@collie-lang/compiler");
-function formatSource(source, options = {}) {
-  return (0, import_compiler.formatCollie)(source, options);
-}
-
-// src/watcher.ts
-var import_chokidar = __toESM(require("chokidar"), 1);
-var import_compiler2 = require("@collie-lang/compiler");
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
-var import_picocolors = __toESM(require("picocolors"), 1);
-
-// src/fs-utils.ts
-var import_node_path = __toESM(require("path"), 1);
-function resolveOutputPath(filepath, baseDir, outDir) {
-  const outputBase = outDir ?? baseDir;
-  const relative = import_node_path.default.relative(baseDir, filepath);
-  const ext = import_node_path.default.extname(relative);
-  const withoutExt = ext ? relative.slice(0, -ext.length) : relative;
-  return import_node_path.default.join(outputBase, `${withoutExt}.tsx`);
-}
-function toDisplayPath(target) {
-  const relative = import_node_path.default.relative(process.cwd(), target);
-  if (!relative || relative.startsWith("..") || relative.startsWith("..\\")) {
-    return target;
-  }
-  return relative;
-}
-
-// src/watcher.ts
-async function watch(inputPath, options = {}) {
-  const resolvedInput = import_node_path2.default.resolve(process.cwd(), inputPath);
-  let stats;
-  try {
-    stats = await import_promises2.default.stat(resolvedInput);
-  } catch {
-    throw new Error(`Input path does not exist: ${inputPath}`);
-  }
-  const isDirectory = stats.isDirectory();
-  const ext = normalizeExtension(options.ext);
-  const baseDir = isDirectory ? resolvedInput : import_node_path2.default.dirname(resolvedInput);
-  const outDir = options.outDir ? import_node_path2.default.resolve(process.cwd(), options.outDir) : void 0;
-  const pattern = isDirectory ? import_node_path2.default.join(resolvedInput, `**/*${ext}`) : resolvedInput;
-  console.log(import_picocolors.default.cyan(`Watching ${toDisplayPath(resolvedInput)} for changes...
-`));
-  const watcher = import_chokidar.default.watch(pattern, {
-    ignored: /node_modules/,
-    persistent: true,
-    ignoreInitial: false
-  });
-  watcher.on("add", (file) => {
-    void compileFile(file, baseDir, outDir, options);
-  });
-  watcher.on("change", (file) => {
-    if (options.verbose) {
-      console.log(import_picocolors.default.gray(`[${getTimestamp()}] Changed: ${toDisplayPath(file)}`));
-    }
-    void compileFile(file, baseDir, outDir, options);
-  });
-  watcher.on("unlink", (file) => {
-    void deleteCompiledFile(file, baseDir, outDir, options);
-  });
-  watcher.on("ready", () => {
-    console.log(import_picocolors.default.green("\nWatching for file changes...\n"));
-  });
-  await new Promise((resolve, reject) => {
-    watcher.on("close", resolve);
-    watcher.on("error", (error) => {
-      const err = error instanceof Error ? error : new Error(String(error));
-      console.error(import_picocolors.default.red(`[collie] Watcher error: ${err.message}`));
-      reject(err);
-    });
-    process.once("SIGINT", () => {
-      console.log(import_picocolors.default.yellow("\nStopping watch mode..."));
-      watcher.close().catch((error) => {
-        const err = error instanceof Error ? error : new Error(String(error));
-        console.error(import_picocolors.default.red(`[collie] Failed to stop watcher: ${err.message}`));
-        reject(err);
-      });
-    });
-  });
-}
-async function compileFile(filepath, baseDir, outDir, options) {
-  try {
-    const source = await import_promises2.default.readFile(filepath, "utf8");
-    const componentName = import_node_path2.default.basename(filepath, import_node_path2.default.extname(filepath));
-    const compileOptions = {
-      filename: filepath,
-      componentNameHint: componentName,
-      jsxRuntime: options.jsxRuntime ?? "automatic"
-    };
-    const result = (0, import_compiler2.compileToTsx)(source, compileOptions);
-    const errors = result.diagnostics.filter((d) => d.severity === "error");
-    if (errors.length) {
-      logDiagnostics(filepath, errors);
-      return;
-    }
-    const outputPath = resolveOutputPath(filepath, baseDir, outDir);
-    await import_promises2.default.mkdir(import_node_path2.default.dirname(outputPath), { recursive: true });
-    await import_promises2.default.writeFile(outputPath, result.code, "utf8");
-    if (options.sourcemap && result.map) {
-      await import_promises2.default.writeFile(`${outputPath}.map`, JSON.stringify(result.map), "utf8");
-    }
-    console.log(import_picocolors.default.green(`[${getTimestamp()}] Compiled ${toDisplayPath(filepath)} \u2192 ${toDisplayPath(outputPath)}`));
-    const warnings = result.diagnostics.filter((d) => d.severity === "warning");
-    if (warnings.length) {
-      logDiagnostics(filepath, warnings);
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(import_picocolors.default.red(`[collie] Failed to compile ${toDisplayPath(filepath)}: ${message}`));
-  }
-}
-async function deleteCompiledFile(filepath, baseDir, outDir, options) {
-  try {
-    const outputPath = resolveOutputPath(filepath, baseDir, outDir);
-    await import_promises2.default.unlink(outputPath);
-    if (options.sourcemap) {
-      await import_promises2.default.unlink(`${outputPath}.map`).catch(() => {
-      });
-    }
-    console.log(import_picocolors.default.yellow(`[${getTimestamp()}] Deleted ${toDisplayPath(outputPath)}`));
-  } catch {
-  }
-}
-function logDiagnostics(file, diagnostics) {
-  for (const diag of diagnostics) {
-    const range = diag.range ?? diag.span;
-    const fileLabel = diag.filePath ?? diag.file ?? file;
-    const location = range ? `${range.start.line}:${range.start.col}` : "";
-    const prefix = location ? `${toDisplayPath(fileLabel)}:${location}` : toDisplayPath(fileLabel);
-    const code = diag.code ? ` (${diag.code})` : "";
-    const writer = diag.severity === "warning" ? import_picocolors.default.yellow : import_picocolors.default.red;
-    console[diag.severity === "warning" ? "warn" : "error"](
-      writer(`${prefix ? `${prefix}: ` : ""}${diag.severity}${code}: ${diag.message}`)
-    );
-  }
-}
-function normalizeExtension(ext) {
-  if (!ext || !ext.trim()) {
-    return ".collie";
-  }
-  return ext.startsWith(".") ? ext : `.${ext}`;
-}
-function getTimestamp() {
-  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
-}
-
-// src/builder.ts
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_compiler3 = require("@collie-lang/compiler");
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-var import_picocolors3 = __toESM(require("picocolors"), 1);
-
-// src/output.ts
-var import_picocolors2 = __toESM(require("picocolors"), 1);
-var SUMMARY_STYLES = {
-  success: { icon: "\u2714", color: import_picocolors2.default.green },
-  warning: { icon: "\u26A0", color: import_picocolors2.default.yellow },
-  error: { icon: "\u2716", color: import_picocolors2.default.red }
-};
-function printSummary(kind, message, detail, nextStep) {
-  const style = SUMMARY_STYLES[kind];
-  console.log(style.color(`${style.icon} ${message}`));
-  if (detail) {
-    console.log(import_picocolors2.default.dim(`Changed: ${detail}`));
-  }
-  if (nextStep) {
-    console.log(import_picocolors2.default.dim(`Next: ${nextStep}`));
-  }
-}
-function formatDiagnosticLine(diag, fallbackFile) {
-  const fileLabel = diag.filePath ?? diag.file ?? fallbackFile ?? "<unknown>";
-  const range = diag.range ?? diag.span;
-  const location = range ? `${fileLabel}:${range.start.line}:${range.start.col}` : fileLabel;
-  const code = diag.code ? ` (${diag.code})` : "";
-  return `${location}: ${diag.severity}${code}: ${diag.message}`;
-}
-
-// src/builder.ts
-async function build(input, options = {}) {
-  const resolvedInput = import_node_path3.default.resolve(process.cwd(), input);
-  let stats;
-  try {
-    stats = await import_promises3.default.stat(resolvedInput);
-  } catch {
-    throw new Error(`Input path does not exist: ${input}`);
-  }
-  const isDirectory = stats.isDirectory();
-  const baseDir = isDirectory ? resolvedInput : import_node_path3.default.dirname(resolvedInput);
-  const outDir = options.outDir ? import_node_path3.default.resolve(process.cwd(), options.outDir) : void 0;
-  const files = isDirectory ? (await (0, import_fast_glob.default)("**/*.collie", { cwd: resolvedInput, absolute: true })).sort() : [resolvedInput];
-  if (!files.length) {
-    if (!options.quiet) {
-      printSummary(
-        "warning",
-        `No .collie files found under ${toDisplayPath(resolvedInput)}`,
-        void 0,
-        "add a .collie file or adjust the input path"
-      );
-    }
-    return { totalFiles: 0, successfulFiles: 0, errors: [] };
-  }
-  if (!options.quiet) {
-    console.log(import_picocolors3.default.cyan(`Compiling ${toDisplayPath(resolvedInput)}...`));
-    console.log("");
-  }
-  const result = {
-    totalFiles: files.length,
-    successfulFiles: 0,
-    errors: []
-  };
-  for (const file of files) {
-    const compileResult = await compileSingleFile(file, baseDir, outDir, options);
-    if (compileResult.success) {
-      result.successfulFiles++;
-      if (!options.quiet) {
-        console.log(import_picocolors3.default.green(`\u2714 ${toDisplayPath(file)} \u2192 ${toDisplayPath(compileResult.outputPath)}`));
-      }
-      if (options.verbose) {
-        logDiagnostics2(file, compileResult.diagnostics.filter((d) => d.severity === "warning"));
-      }
-    } else {
-      result.errors.push({ file, diagnostics: compileResult.diagnostics });
-      logDiagnostics2(file, compileResult.diagnostics, true);
-    }
-  }
-  if (!options.quiet) {
-    console.log("");
-    if (result.errors.length === 0) {
-      const changeDetail = outDir ? `wrote ${result.successfulFiles} .tsx file${result.successfulFiles === 1 ? "" : "s"} to ${toDisplayPath(outDir)}` : `wrote ${result.successfulFiles} .tsx file${result.successfulFiles === 1 ? "" : "s"} next to the source files`;
-      printSummary(
-        "success",
-        `Compiled ${result.totalFiles} .collie file${result.totalFiles === 1 ? "" : "s"}`,
-        changeDetail,
-        "import the generated .tsx files in your app"
-      );
-    } else {
-      const changeDetail = result.successfulFiles > 0 ? `wrote ${result.successfulFiles} .tsx file${result.successfulFiles === 1 ? "" : "s"} before failing` : void 0;
-      printSummary(
-        "error",
-        `Build failed with ${result.errors.length} error${result.errors.length === 1 ? "" : "s"}`,
-        changeDetail,
-        "fix the errors above and rerun collie build"
-      );
-    }
-  }
-  return result;
-}
-async function compileSingleFile(filepath, baseDir, outDir, options) {
-  try {
-    const source = await import_promises3.default.readFile(filepath, "utf8");
-    const componentName = import_node_path3.default.basename(filepath, import_node_path3.default.extname(filepath));
-    const compileOptions = {
-      filename: filepath,
-      componentNameHint: componentName,
-      jsxRuntime: options.jsxRuntime ?? "automatic"
-    };
-    const result = (0, import_compiler3.compileToTsx)(source, compileOptions);
-    const errors = result.diagnostics.filter((d) => d.severity === "error");
-    if (errors.length) {
-      return { success: false, diagnostics: errors };
-    }
-    const outputPath = resolveOutputPath(filepath, baseDir, outDir);
-    await import_promises3.default.mkdir(import_node_path3.default.dirname(outputPath), { recursive: true });
-    await import_promises3.default.writeFile(outputPath, result.code, "utf8");
-    if (options.sourcemap && result.map) {
-      await import_promises3.default.writeFile(`${outputPath}.map`, JSON.stringify(result.map), "utf8");
-    }
-    return { success: true, outputPath, diagnostics: result.diagnostics };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      diagnostics: [
-        {
-          severity: "error",
-          message,
-          file: filepath
-        }
-      ]
-    };
-  }
-}
-function logDiagnostics2(file, diagnostics, force = false) {
-  if (!diagnostics.length) {
-    return;
-  }
-  for (const diag of diagnostics) {
-    if (!force && diag.severity !== "warning") {
-      continue;
-    }
-    const displayFile = diag.file ? toDisplayPath(diag.file) : toDisplayPath(file);
-    const message = formatDiagnosticLine({ ...diag, file: displayFile }, toDisplayPath(file));
-    const writer = diag.severity === "warning" ? import_picocolors3.default.yellow : import_picocolors3.default.red;
-    console[diag.severity === "warning" ? "warn" : "error"](writer(message));
-  }
-}
-
-// src/checker.ts
-var import_fast_glob2 = __toESM(require("fast-glob"), 1);
-var import_compiler4 = require("@collie-lang/compiler");
-var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-var import_picocolors4 = __toESM(require("picocolors"), 1);
-async function scanTemplates(patterns) {
-  const files = await (0, import_fast_glob2.default)(patterns, {
-    absolute: true,
-    onlyFiles: true,
-    dot: false,
-    unique: true
-  });
-  if (files.length === 0) {
-    throw new Error("No .collie files found for the provided patterns.");
-  }
-  const lineCache = /* @__PURE__ */ new Map();
-  const diagnostics = [];
-  const templates = [];
-  for (const file of files) {
-    const displayPath = toDisplayPath(file);
-    try {
-      const source = await import_promises4.default.readFile(file, "utf8");
-      lineCache.set(displayPath, source.split(/\r?\n/));
-      const parseResult = (0, import_compiler4.parseCollie)(source, { filename: file });
-      for (const diag of parseResult.diagnostics) {
-        const range = diag.range ?? diag.span;
-        const normalized = {
-          ...diag,
-          file: diag.file ? toDisplayPath(import_node_path4.default.isAbsolute(diag.file) ? diag.file : import_node_path4.default.resolve(import_node_path4.default.dirname(file), diag.file)) : displayPath,
-          filePath: diag.filePath ? toDisplayPath(
-            import_node_path4.default.isAbsolute(diag.filePath) ? diag.filePath : import_node_path4.default.resolve(import_node_path4.default.dirname(file), diag.filePath)
-          ) : displayPath,
-          range
-        };
-        diagnostics.push(normalized);
-      }
-      for (const template of parseResult.templates) {
-        templates.push({
-          id: template.id,
-          filePath: file,
-          displayPath,
-          span: template.span
-        });
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      diagnostics.push({
-        severity: "error",
-        message,
-        file: displayPath,
-        filePath: displayPath
-      });
-    }
-  }
-  return { files, templates, diagnostics, lineCache };
-}
-function buildDuplicateDiagnostics(templates) {
-  const duplicates = /* @__PURE__ */ new Map();
-  for (const template of templates) {
-    const list = duplicates.get(template.id) ?? [];
-    list.push(template);
-    duplicates.set(template.id, list);
-  }
-  const diagnostics = [];
-  for (const [id, locations] of duplicates) {
-    const uniqueFiles = new Set(locations.map((location) => location.filePath));
-    if (uniqueFiles.size <= 1) {
-      continue;
-    }
-    for (const location of locations) {
-      const otherLocations = locations.filter((entry) => entry !== location).map((entry) => formatTemplateLocation(entry)).join(", ");
-      const suffix = otherLocations ? ` Also defined in ${otherLocations}.` : "";
-      diagnostics.push({
-        severity: "error",
-        code: "COLLIE703",
-        message: `Duplicate template id "${id}".${suffix}`,
-        file: location.displayPath,
-        filePath: location.displayPath,
-        range: location.span
-      });
-    }
-  }
-  return diagnostics;
-}
-function formatTemplateLocation(template) {
-  const span = template.span;
-  if (span) {
-    return `${template.displayPath}:${span.start.line}:${span.start.col}`;
-  }
-  return template.displayPath;
-}
-async function check(patterns, options = {}) {
-  const scan = await scanTemplates(patterns);
-  const diagnostics = [];
-  const filesWithErrors = /* @__PURE__ */ new Set();
-  const filesWithWarnings = /* @__PURE__ */ new Set();
-  let errorCount = 0;
-  let warningCount = 0;
-  for (const diag of scan.diagnostics) {
-    const fileLabel = diag.filePath ?? diag.file;
-    if (diag.severity === "error") {
-      if (fileLabel) {
-        filesWithErrors.add(fileLabel);
-      }
-      errorCount++;
-      diagnostics.push(diag);
-    } else {
-      warningCount++;
-      if (fileLabel) {
-        filesWithWarnings.add(fileLabel);
-      }
-      if (!options.noWarnings) {
-        diagnostics.push(diag);
-      }
-    }
-  }
-  const duplicateDiagnostics = buildDuplicateDiagnostics(scan.templates);
-  for (const diag of duplicateDiagnostics) {
-    const fileLabel = diag.filePath ?? diag.file;
-    if (fileLabel) {
-      filesWithErrors.add(fileLabel);
-    }
-    errorCount++;
-    diagnostics.push(diag);
-  }
-  const result = {
-    totalFiles: scan.files.length,
-    filesWithErrors: filesWithErrors.size,
-    filesWithWarnings: filesWithWarnings.size,
-    diagnostics,
-    errorCount,
-    warningCount
-  };
-  if ((options.format ?? "text") === "json") {
-    console.log(JSON.stringify(result, null, 2));
-  } else {
-    console.log(import_picocolors4.default.cyan(`Checking ${scan.files.length} file${scan.files.length === 1 ? "" : "s"}...
-`));
-    printTextDiagnostics(result, options, scan.lineCache);
-  }
-  return result;
-}
-function printTextDiagnostics(result, options, lineCache) {
-  const hasDiagnostics = result.diagnostics.length > 0;
-  if (hasDiagnostics) {
-    for (const diag of result.diagnostics) {
-      const message = formatDiagnosticLine(diag);
-      const writer = diag.severity === "warning" ? import_picocolors4.default.yellow : import_picocolors4.default.red;
-      console.log(writer(message));
-      const range = diag.range ?? diag.span;
-      const fileLabel = diag.filePath ?? diag.file;
-      if (options.verbose && range && fileLabel) {
-        const lines = lineCache.get(fileLabel);
-        if (lines) {
-          const index = Math.max(0, range.start.line - 1);
-          const text = lines[index] ?? "";
-          const markerStart = Math.max(0, range.start.col - 1);
-          const width = Math.max(1, range.end.col - range.start.col);
-          const indicator = `${" ".repeat(markerStart)}${"^".repeat(width)}`;
-          console.log(import_picocolors4.default.dim(`  ${text}`));
-          console.log(import_picocolors4.default.dim(`  ${indicator}`));
-        }
-      }
-      if (options.verbose) {
-        console.log("");
-      }
-    }
-    if (!options.verbose) {
-      console.log("");
-    }
-  }
-  const warningCount = options.noWarnings ? 0 : result.warningCount;
-  const hasWarnings = warningCount > 0;
-  const hasErrors = result.errorCount > 0;
-  const summaryParts = [];
-  if (hasErrors) {
-    summaryParts.push(`${result.errorCount} error${result.errorCount === 1 ? "" : "s"}`);
-  }
-  if (hasWarnings) {
-    summaryParts.push(`${warningCount} warning${warningCount === 1 ? "" : "s"}`);
-  }
-  const summarySuffix = summaryParts.length > 0 ? ` with ${summaryParts.join(" and ")}` : " with no issues";
-  const summary = `Checked ${result.totalFiles} file${result.totalFiles === 1 ? "" : "s"}${summarySuffix}`;
-  if (hasErrors) {
-    printSummary("error", summary, "no files changed", "fix the errors above and rerun collie check");
-  } else if (hasWarnings) {
-    printSummary("warning", summary, "no files changed", "review the warnings above");
-  } else {
-    printSummary("success", summary, "no files changed", "run collie build when you are ready to compile");
-  }
-}
-
-// src/creator.ts
-var import_prompts = __toESM(require("prompts"), 1);
-var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_node_fs = require("fs");
-var import_node_path5 = __toESM(require("path"), 1);
-var import_node_child_process = require("child_process");
-var import_node_url = require("url");
-var import_picocolors5 = __toESM(require("picocolors"), 1);
-var import_meta = {};
-var TEMPLATE_MAP = {
-  vite: {
-    label: "Vite + React",
-    description: "Vite 5 + React 18 starter with Collie support",
-    variants: {
-      ts: "vite-react-ts",
-      js: "vite-react-js"
-    }
-  },
-  "nextjs-app-router": {
-    label: "Next.js App Router",
-    description: "Next.js 14 App Router starter wired with @collie-lang/next",
-    variants: {
-      ts: "nextjs-app-router-ts",
-      js: "nextjs-app-router-js"
-    }
-  }
-};
-var TEMPLATE_ALIASES = {
-  next: { template: "nextjs-app-router" },
-  nextjs: { template: "nextjs-app-router", forcedTypescript: true },
-  "nextjs-app": { template: "nextjs-app-router", forcedTypescript: true }
-};
-function formatTemplateList() {
-  return Object.entries(TEMPLATE_MAP).map(([key, meta]) => {
-    const variantInfo = [
-      `${meta.variants.ts} (TypeScript)`,
-      `${meta.variants.js} (JavaScript)`
-    ].join(", ");
-    return [
-      `  \u2022 ${key} \u2013 ${meta.label}`,
-      `    ${meta.description}`,
-      `    Variants: ${variantInfo}`
-    ].join("\n");
-  }).join("\n");
-}
-async function create(options = {}) {
-  const resolved = await promptForOptions(options);
-  const targetDir = import_node_path5.default.resolve(process.cwd(), resolved.projectName);
-  if ((0, import_node_fs.existsSync)(targetDir)) {
-    const overwrite = await confirmOverwrite(resolved.projectName);
-    if (!overwrite) {
-      console.log(import_picocolors5.default.yellow("Cancelled"));
-      return;
-    }
-    await import_promises5.default.rm(targetDir, { recursive: true, force: true });
-  }
-  console.log(import_picocolors5.default.cyan(`
-Creating project in ${targetDir}...
-`));
-  const templateDir = getTemplateDir(resolved.template, resolved.typescript);
-  await copyTemplate(templateDir, targetDir, resolved.projectName);
-  console.log(import_picocolors5.default.green("\u2714 Copied template files"));
-  if (!resolved.noGit) {
-    try {
-      await runCommand("git", ["init"], targetDir);
-      console.log(import_picocolors5.default.green("\u2714 Initialized git repository"));
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.log(import_picocolors5.default.yellow(`\u26A0 Failed to initialize git: ${message}`));
-    }
-  }
-  if (!resolved.noInstall) {
-    console.log(import_picocolors5.default.cyan(`\u2714 Installing dependencies with ${resolved.packageManager}...`));
-    try {
-      await installDependencies(resolved.packageManager, targetDir);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.log(import_picocolors5.default.yellow(`\u26A0 Failed to install dependencies: ${message}`));
-      console.log(import_picocolors5.default.yellow("  Run the install command manually once you're ready."));
-    }
-  }
-  printSuccessMessage(resolved);
-}
-async function promptForOptions(options) {
-  const detected = detectPackageManager();
-  const questions = [];
-  if (!options.projectName) {
-    questions.push({
-      type: "text",
-      name: "projectName",
-      message: "Project name:",
-      initial: "my-collie-app",
-      validate: (value) => {
-        if (!value.trim()) return "Project name is required";
-        if (!/^[a-z0-9-_]+$/i.test(value.trim())) return "Use letters, numbers, hyphens, or underscores.";
-        return true;
-      }
-    });
-  }
-  if (!options.template) {
-    const choices = Object.entries(TEMPLATE_MAP).map(([value, meta]) => ({
-      title: meta.label,
-      value
-    }));
-    questions.push({
-      type: "select",
-      name: "template",
-      message: "Select a template:",
-      choices,
-      initial: 0
-    });
-  }
-  if (options.typescript === void 0) {
-    questions.push({
-      type: "confirm",
-      name: "typescript",
-      message: "Use TypeScript?",
-      initial: true
-    });
-  }
-  if (!options.packageManager) {
-    questions.push({
-      type: "select",
-      name: "packageManager",
-      message: "Package manager:",
-      choices: [
-        { title: "pnpm", value: "pnpm" },
-        { title: "npm", value: "npm" },
-        { title: "yarn", value: "yarn" }
-      ],
-      initial: detected === "pnpm" ? 0 : detected === "npm" ? 1 : 2
-    });
-  }
-  const answers = questions.length > 0 ? await (0, import_prompts.default)(questions, {
-    onCancel: () => {
-      console.log(import_picocolors5.default.yellow("\nCancelled"));
-      process.exit(0);
-    }
-  }) : {};
-  const templateResult = resolveTemplate((options.template || answers.template || "vite").trim());
-  const typescript = templateResult.forcedTypescript ?? (options.typescript !== void 0 ? options.typescript : answers.typescript ?? true);
-  const packageManager = options.packageManager || answers.packageManager || detected;
-  if (!["npm", "yarn", "pnpm"].includes(packageManager)) {
-    throw new Error(`Unsupported package manager: ${packageManager}`);
-  }
-  return {
-    projectName: (options.projectName || answers.projectName).trim(),
-    template: templateResult.template,
-    typescript,
-    packageManager,
-    noInstall: options.noInstall ?? false,
-    noGit: options.noGit ?? false
-  };
-}
-function resolveTemplate(input) {
-  const normalized = input.trim().toLowerCase();
-  if (TEMPLATE_MAP[normalized]) {
-    return { template: normalized };
-  }
-  const alias = TEMPLATE_ALIASES[normalized];
-  if (alias && TEMPLATE_MAP[alias.template]) {
-    return { template: alias.template, forcedTypescript: alias.forcedTypescript };
-  }
-  for (const key of Object.keys(TEMPLATE_MAP)) {
-    const meta = TEMPLATE_MAP[key];
-    if (meta.variants.ts === normalized) {
-      return { template: key, forcedTypescript: true };
-    }
-    if (meta.variants.js === normalized) {
-      return { template: key, forcedTypescript: false };
-    }
-  }
-  return throwInvalidTemplateError(input);
-}
-function throwInvalidTemplateError(input) {
-  const list = formatTemplateList();
-  throw new Error(
-    `Invalid template: '${input}'.
-
-Available templates:
-${list}
-
-Usage: collie create <project-name> --template <template>`
-  );
-}
-async function confirmOverwrite(projectName) {
-  const { overwrite } = await (0, import_prompts.default)({
-    type: "confirm",
-    name: "overwrite",
-    message: `Directory ${projectName} already exists. Overwrite?`,
-    initial: false
-  });
-  return Boolean(overwrite);
-}
-function getTemplateDir(template, typescript) {
-  const meta = TEMPLATE_MAP[template];
-  const variant = typescript ? meta.variants.ts : meta.variants.js;
-  const dir = import_node_path5.default.resolve(import_node_path5.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url)), "..", "templates", variant);
-  if (!(0, import_node_fs.existsSync)(dir)) {
-    throw new Error(
-      `Template '${template}' with ${typescript ? "TypeScript" : "JavaScript"} is not available.`
-    );
-  }
-  return dir;
-}
-async function copyTemplate(templateDir, targetDir, projectName) {
-  await import_promises5.default.mkdir(targetDir, { recursive: true });
-  await copyDirectory(templateDir, targetDir, { projectName });
-}
-async function copyDirectory(source, target, context) {
-  const entries = await import_promises5.default.readdir(source, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = import_node_path5.default.join(source, entry.name);
-    const destName = entry.name.endsWith(".template") ? entry.name.replace(/\.template$/, "") : entry.name;
-    const destPath = import_node_path5.default.join(target, destName);
-    if (entry.isDirectory()) {
-      await import_promises5.default.mkdir(destPath, { recursive: true });
-      await copyDirectory(srcPath, destPath, context);
-    } else {
-      const buffer = await import_promises5.default.readFile(srcPath);
-      if (entry.name.endsWith(".template")) {
-        const content = buffer.toString("utf8").replace(/__PROJECT_NAME__/g, context.projectName);
-        await import_promises5.default.writeFile(destPath, content, "utf8");
-      } else {
-        await import_promises5.default.writeFile(destPath, buffer);
-      }
-    }
-  }
-}
-async function installDependencies(packageManager, cwd) {
-  const args = packageManager === "npm" ? ["install"] : packageManager === "yarn" ? ["install"] : ["install"];
-  await runCommand(packageManager, args, cwd);
-}
-function runCommand(command, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = (0, import_node_child_process.spawn)(command, args, { cwd, stdio: "inherit" });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
-    });
-  });
-}
-function detectPackageManager() {
-  const userAgent = process.env.npm_config_user_agent ?? "";
-  if (userAgent.startsWith("pnpm")) return "pnpm";
-  if (userAgent.startsWith("yarn")) return "yarn";
-  if (userAgent.startsWith("npm")) return "npm";
-  return "pnpm";
-}
-function printSuccessMessage(config) {
-  const cdCommand = `cd ${config.projectName}`;
-  const installCommand = config.packageManager === "npm" ? "npm install" : `${config.packageManager} install`;
-  const devCommand = config.packageManager === "npm" ? "npm run dev" : `${config.packageManager} dev`;
-  console.log(import_picocolors5.default.green(`
-\u{1F389} Success! Created ${config.projectName}
-`));
-  console.log("Next steps:");
-  console.log(import_picocolors5.default.cyan(`  ${cdCommand}`));
-  if (config.noInstall) {
-    console.log(import_picocolors5.default.cyan(`  ${installCommand}`));
-  }
-  console.log(import_picocolors5.default.cyan(`  ${devCommand}`));
-  console.log(import_picocolors5.default.gray("\nHappy coding with Collie! \u{1F415}\n"));
-}
-
-// src/nextjs-setup.ts
-var import_promises6 = __toESM(require("fs/promises"), 1);
-var import_node_fs2 = require("fs");
-var import_node_path6 = __toESM(require("path"), 1);
-var import_picocolors6 = __toESM(require("picocolors"), 1);
-var import_next = require("@collie-lang/next");
-function hasNextDependency(pkg) {
-  return Boolean(pkg?.dependencies?.next || pkg?.devDependencies?.next);
-}
-
-// src/converter.ts
-var import_promises7 = __toESM(require("fs/promises"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
-var import_compiler5 = require("@collie-lang/compiler");
-async function convertFile(filepath, options = {}) {
-  const source = await import_promises7.default.readFile(filepath, "utf8");
-  const result = (0, import_compiler5.convertTsxToCollie)(source, { filename: filepath });
-  const { collie, warnings } = result;
-  let outputPath;
-  if (options.write) {
-    outputPath = resolveOutputPath2(filepath);
-    if (!options.overwrite) {
-      const exists = await fileExists(outputPath);
-      if (exists) {
-        throw new Error(`${import_node_path7.default.relative(process.cwd(), outputPath)} already exists. Use --overwrite to replace.`);
-      }
-    }
-    await import_promises7.default.mkdir(import_node_path7.default.dirname(outputPath), { recursive: true });
-    await import_promises7.default.writeFile(outputPath, collie, "utf8");
-    if (options.removeOriginal) {
-      await import_promises7.default.unlink(filepath);
-    }
-  }
-  return { collie, warnings, outputPath };
-}
-function resolveOutputPath2(filepath) {
-  return filepath.replace(/\.[tj]sx?$/, "") + ".collie";
-}
-async function fileExists(filepath) {
-  try {
-    await import_promises7.default.access(filepath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/doctor.ts
-var import_compiler6 = require("@collie-lang/compiler");
-var import_fast_glob3 = __toESM(require("fast-glob"), 1);
-var import_promises8 = __toESM(require("fs/promises"), 1);
-var import_node_fs3 = require("fs");
-var import_node_path8 = __toESM(require("path"), 1);
-var import_picocolors7 = __toESM(require("picocolors"), 1);
-var VITE_CONFIG_FILES = ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"];
-var NEXT_CONFIG_FILES = ["next.config.ts", "next.config.mjs", "next.config.js"];
-var DECLARATION_CANDIDATES = ["src/collie.d.ts", "app/collie.d.ts", "collie.d.ts"];
-async function runDoctor(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const context = {
-    cwd,
-    packageJson: await readPackageJson(cwd)
-  };
-  const results = [];
-  results.push(checkNodeVersion());
-  const compilerResult = checkCompilerDependency(context);
-  results.push(compilerResult);
-  const buildInfo = detectBuildSystem(context);
-  results.push(buildInfo.result);
-  if (buildInfo.type === "vite") {
-    const viteDependency = checkDependency(context, "@collie-lang/vite", "Collie Vite plugin", ["vite"]);
-    if (viteDependency) {
-      results.push(viteDependency);
-    }
-    results.push(await checkViteConfig(context));
-  } else if (buildInfo.type === "nextjs") {
-    const nextDependency = checkDependency(context, "@collie-lang/next", "Collie Next.js integration", ["nextjs"]);
-    if (nextDependency) {
-      results.push(nextDependency);
-    }
-    results.push(await checkNextConfig(context));
-  }
-  results.push(await checkTypeDeclarations(context));
-  results.push(await checkCollieFiles(context));
-  results.push(await testCompilation());
-  return results;
-}
-function filterDiagnostics(results, filter) {
-  if (!filter) {
-    return results;
-  }
-  const normalized = filter.trim().toLowerCase();
-  if (!normalized) {
-    return results;
-  }
-  return results.filter((result) => {
-    if (result.tags?.some((tag) => tag.toLowerCase() === normalized)) {
-      return true;
-    }
-    return result.check.toLowerCase().includes(normalized);
-  });
-}
-function printDoctorResults(results) {
-  console.log(import_picocolors7.default.bold("collie doctor"));
-  console.log(import_picocolors7.default.dim("Diagnosing your environment..."));
-  console.log("");
-  let errors = 0;
-  let warnings = 0;
-  for (const result of results) {
-    const icon = result.status === "pass" ? import_picocolors7.default.green("\u2714") : result.status === "warn" ? import_picocolors7.default.yellow("\u26A0") : import_picocolors7.default.red("\u2716");
-    console.log(`${icon} ${result.check}: ${result.message}`);
-    if (result.fix) {
-      console.log(import_picocolors7.default.dim(`  Fix: ${result.fix}`));
-    }
-    console.log("");
-    if (result.status === "fail") {
-      errors++;
-    } else if (result.status === "warn") {
-      warnings++;
-    }
-  }
-  if (errors === 0 && warnings === 0) {
-    printSummary("success", "All checks passed", "no changes made", "continue with collie check or collie build");
-    return;
-  }
-  const summary = [];
-  if (errors > 0) summary.push(`${errors} error${errors === 1 ? "" : "s"}`);
-  if (warnings > 0) summary.push(`${warnings} warning${warnings === 1 ? "" : "s"}`);
-  printSummary(
-    errors > 0 ? "error" : "warning",
-    `Doctor found ${summary.join(" and ")}`,
-    "no changes made",
-    "address the items above and rerun collie doctor"
-  );
-}
-function checkNodeVersion() {
-  const version = process.version;
-  const major = Number(version.slice(1).split(".")[0]);
-  if (Number.isFinite(major) && major >= 18) {
-    return {
-      id: "node-version",
-      check: "Node.js version",
-      status: "pass",
-      message: `${version} (compatible)`,
-      tags: ["node"]
-    };
-  }
-  return {
-    id: "node-version",
-    check: "Node.js version",
-    status: "fail",
-    message: `${version} (incompatible)`,
-    fix: "Upgrade to Node.js 18 or newer.",
-    tags: ["node"]
-  };
-}
-function checkCompilerDependency(context) {
-  const spec = getDependencySpec(context.packageJson, "@collie-lang/compiler");
-  if (!spec) {
-    return {
-      id: "compiler-dependency",
-      check: "Collie compiler",
-      status: "fail",
-      message: context.packageJson ? "Not found in package.json" : "package.json not found",
-      fix: "Install @collie-lang/compiler (e.g. npm install --save-dev @collie-lang/compiler)",
-      tags: ["compiler"]
-    };
-  }
-  return {
-    id: "compiler-dependency",
-    check: "Collie compiler",
-    status: "pass",
-    message: `@collie-lang/compiler@${formatDependencyVersion(spec)}`,
-    tags: ["compiler"]
-  };
-}
-function detectBuildSystem(context) {
-  if (!context.packageJson) {
-    return {
-      type: null,
-      result: {
-        id: "build-system",
-        check: "Build system",
-        status: "warn",
-        message: "package.json not found",
-        fix: "Initialize a project (npm init) and install Vite or Next.js.",
-        tags: ["build"]
-      }
-    };
-  }
-  const hasVite = hasDependency(context.packageJson, "vite");
-  const hasNext = hasDependency(context.packageJson, "next");
-  if (hasVite && hasNext) {
-    return {
-      type: "vite",
-      result: {
-        id: "build-system",
-        check: "Build system",
-        status: "warn",
-        message: "Both Vite and Next.js detected (defaulting to Vite)",
-        tags: ["build"]
-      }
-    };
-  }
-  if (hasVite) {
-    return {
-      type: "vite",
-      result: {
-        id: "build-system",
-        check: "Build system",
-        status: "pass",
-        message: "Vite detected",
-        tags: ["build", "vite"]
-      }
-    };
-  }
-  if (hasNext) {
-    return {
-      type: "nextjs",
-      result: {
-        id: "build-system",
-        check: "Build system",
-        status: "pass",
-        message: "Next.js detected",
-        tags: ["build", "nextjs"]
-      }
-    };
-  }
-  return {
-    type: null,
-    result: {
-      id: "build-system",
-      check: "Build system",
-      status: "warn",
-      message: "No Vite or Next.js dependency found",
-      fix: "Install Vite or Next.js for the best Collie experience.",
-      tags: ["build"]
-    }
-  };
-}
-function checkDependency(context, dependency, label, tags) {
-  if (!context.packageJson) {
-    return null;
-  }
-  const spec = getDependencySpec(context.packageJson, dependency);
-  if (!spec) {
-    return {
-      id: `${dependency}-dependency`,
-      check: label,
-      status: "fail",
-      message: `${dependency} missing from package.json`,
-      fix: `Install ${dependency} (e.g. npm install --save-dev ${dependency})`,
-      tags
-    };
-  }
-  return {
-    id: `${dependency}-dependency`,
-    check: label,
-    status: "pass",
-    message: `${dependency}@${formatDependencyVersion(spec)}`,
-    tags
-  };
-}
-async function checkViteConfig(context) {
-  for (const filename of VITE_CONFIG_FILES) {
-    const configPath = import_node_path8.default.join(context.cwd, filename);
-    if (!(0, import_node_fs3.existsSync)(configPath)) continue;
-    const contents = await import_promises8.default.readFile(configPath, "utf8");
-    const hasPlugin = /@collie-lang\/vite/.test(contents) && /collie\s*\(/.test(contents);
-    if (hasPlugin) {
-      return {
-        id: "vite-config",
-        check: "Vite config",
-        status: "pass",
-        message: `Collie plugin configured in ${filename}`,
-        tags: ["vite", "config"]
-      };
-    }
-    return {
-      id: "vite-config",
-      check: "Vite config",
-      status: "fail",
-      message: `Found ${filename} but Collie plugin not configured`,
-      fix: "Add collie() to your Vite plugins array or run collie init.",
-      tags: ["vite", "config"]
-    };
-  }
-  return {
-    id: "vite-config",
-    check: "Vite config",
-    status: "fail",
-    message: "Vite config not found",
-    fix: "Create vite.config.ts and add the Collie plugin.",
-    tags: ["vite", "config"]
-  };
-}
-async function checkNextConfig(context) {
-  for (const filename of NEXT_CONFIG_FILES) {
-    const configPath = import_node_path8.default.join(context.cwd, filename);
-    if (!(0, import_node_fs3.existsSync)(configPath)) continue;
-    const contents = await import_promises8.default.readFile(configPath, "utf8");
-    const hasLoader = /@collie-lang\/next/.test(contents) || /withCollie\s*\(/.test(contents);
-    if (hasLoader) {
-      return {
-        id: "next-config",
-        check: "Next.js config",
-        status: "pass",
-        message: `Collie loader configured in ${filename}`,
-        tags: ["nextjs", "config"]
-      };
-    }
-    return {
-      id: "next-config",
-      check: "Next.js config",
-      status: "fail",
-      message: `Found ${filename} but Collie loader not configured`,
-      fix: "Wrap your Next.js config with withCollie() or run collie init --nextjs.",
-      tags: ["nextjs", "config"]
-    };
-  }
-  return {
-    id: "next-config",
-    check: "Next.js config",
-    status: "fail",
-    message: "Next.js config not found",
-    fix: "Create next.config.js and configure withCollie().",
-    tags: ["nextjs", "config"]
-  };
-}
-async function checkTypeDeclarations(context) {
-  for (const relativePath of DECLARATION_CANDIDATES) {
-    const fullPath = import_node_path8.default.join(context.cwd, relativePath);
-    if ((0, import_node_fs3.existsSync)(fullPath)) {
-      return {
-        id: "type-declarations",
-        check: "Type declarations",
-        status: "pass",
-        message: `Found ${relativePath}`,
-        tags: ["types"]
-      };
-    }
-  }
-  return {
-    id: "type-declarations",
-    check: "Type declarations",
-    status: "warn",
-    message: "collie.d.ts not found",
-    fix: "Create src/collie.d.ts so TypeScript recognizes .collie imports.",
-    tags: ["types"]
-  };
-}
-async function checkCollieFiles(context) {
-  const files = await (0, import_fast_glob3.default)("**/*.collie", {
-    cwd: context.cwd,
-    ignore: ["node_modules/**", "dist/**", ".next/**"],
-    absolute: false
-  });
-  if (files.length === 0) {
-    return {
-      id: "collie-files",
-      check: "Collie files",
-      status: "warn",
-      message: "No .collie files found",
-      fix: "Create a .collie template to start using Collie.",
-      tags: ["templates"]
-    };
-  }
-  return {
-    id: "collie-files",
-    check: "Collie files",
-    status: "pass",
-    message: `Found ${files.length} .collie file${files.length === 1 ? "" : "s"}`,
-    tags: ["templates"]
-  };
-}
-async function testCompilation() {
-  const template = ["props", '  name: string = "world"', "", 'div class="doctor-check"', "  h1", "    Hello {{ name }}"].join(
-    "\n"
-  );
-  try {
-    const result = (0, import_compiler6.compileToJsx)(template, { componentNameHint: "DoctorCheck" });
-    const hasError = result.diagnostics.some((diag) => diag.severity === "error");
-    if (hasError) {
-      return {
-        id: "compiler-test",
-        check: "Test compilation",
-        status: "fail",
-        message: "Compiler produced errors",
-        fix: "Reinstall @collie-lang/compiler or inspect diagnostics.",
-        tags: ["compiler"]
-      };
-    }
-    return {
-      id: "compiler-test",
-      check: "Test compilation",
-      status: "pass",
-      message: "Successful",
-      tags: ["compiler"]
-    };
-  } catch {
-    return {
-      id: "compiler-test",
-      check: "Test compilation",
-      status: "fail",
-      message: "Failed to compile sample template",
-      fix: "Verify @collie-lang/compiler is installed correctly.",
-      tags: ["compiler"]
-    };
-  }
-}
-async function readPackageJson(cwd) {
-  try {
-    const pkgPath = import_node_path8.default.join(cwd, "package.json");
-    const raw = await import_promises8.default.readFile(pkgPath, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function getDependencySpec(pkg, name) {
-  if (!pkg) {
-    return void 0;
-  }
-  return pkg.dependencies?.[name] ?? pkg.devDependencies?.[name];
-}
-function hasDependency(pkg, name) {
-  return Boolean(pkg.dependencies?.[name] ?? pkg.devDependencies?.[name]);
-}
-function formatDependencyVersion(spec) {
-  return spec.replace(/^workspace:/, "").replace(/^[~^]/, "");
-}
-
-// src/index.ts
-var import_meta2 = {};
-var VITE_CONFIG_FILES2 = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"];
-var TAILWIND_CONFIG_FILES = [
-  "tailwind.config.js",
-  "tailwind.config.cjs",
-  "tailwind.config.mjs",
-  "tailwind.config.ts"
-];
-var POSTCSS_CONFIG_FILES = [
-  "postcss.config.js",
-  "postcss.config.cjs",
-  "postcss.config.mjs",
-  "postcss.config.ts"
-];
-var COLLIE_CONFIG_FILES = [
-  "collie.config.ts",
-  "collie.config.js",
-  "collie.config.mjs",
-  "collie.config.cjs",
-  "collie.config.json"
-];
-var CLI_PACKAGE_INFO = readCliPackageInfo();
-var CLI_PACKAGE_VERSION = CLI_PACKAGE_INFO.version;
-var CLI_DEPENDENCY_SPECS = CLI_PACKAGE_INFO.dependencies;
-var DEFAULT_DEPENDENCY_RANGE = CLI_PACKAGE_VERSION === "latest" ? "latest" : `^${CLI_PACKAGE_VERSION}`;
-var COLLIE_COMPILER_DEPENDENCY = formatCollieDependency("@collie-lang/compiler");
-var COLLIE_VITE_DEPENDENCY = formatCollieDependency("@collie-lang/vite");
-var COLLIE_NEXT_DEPENDENCY = formatCollieDependency("@collie-lang/next");
-var COLLIE_NEXT_VERSION_RANGE = normalizeDependencyRange(
-  CLI_DEPENDENCY_SPECS["@collie-lang/next"],
-  DEFAULT_DEPENDENCY_RANGE
-);
-var COLLIE_CORE_PACKAGES = ["@collie-lang/compiler", "@collie-lang/config"];
-var COLLIE_VITE_PACKAGES = [
-  ...COLLIE_CORE_PACKAGES,
-  "@collie-lang/vite",
-  "@collie-lang/html-runtime"
-];
-var COLLIE_NEXT_PACKAGES = [...COLLIE_CORE_PACKAGES, "@collie-lang/next"];
-var PROMPT_OPTIONS = {
-  onCancel: () => {
-    console.log(import_picocolors8.default.yellow("\nCancelled"));
-    process.exit(0);
-  }
-};
-var preflightCompleted = false;
-async function main() {
-  const args = process.argv.slice(2);
-  const cmd = args[0];
-  if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
-    printHelp();
-    return;
-  }
-  if (cmd === "format") {
-    try {
-      await runFormat(args.slice(1));
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      printCliError(message);
-      process.exit(1);
-    }
-    return;
-  }
-  if (cmd === "check") {
-    const rest = args.slice(1);
-    const patterns = rest.filter((arg) => !arg.startsWith("-"));
-    if (patterns.length === 0) {
-      throw new Error("No file patterns provided. Usage: collie check <files...>");
-    }
-    const formatValue = getFlag(rest, "--format");
-    const format = formatValue ? validateFormatFlag(formatValue) : "text";
-    const maxWarningsValue = getFlag(rest, "--max-warnings");
-    let maxWarnings = -1;
-    if (maxWarningsValue !== void 0) {
-      const parsed = Number(maxWarningsValue);
-      if (!Number.isInteger(parsed) || parsed < 0) {
-        throw new Error("--max-warnings expects a non-negative integer.");
-      }
-      maxWarnings = parsed;
-    }
-    const options = {
-      verbose: hasFlag(rest, "--verbose", "-v"),
-      format,
-      noWarnings: hasFlag(rest, "--no-warnings"),
-      maxWarnings: maxWarnings >= 0 ? maxWarnings : void 0
-    };
-    const shouldContinue = await runPreflight("check");
-    if (!shouldContinue) {
-      return;
-    }
-    const result = await check(patterns, options);
-    if (result.errorCount > 0) {
-      process.exitCode = 1;
-    } else if (maxWarnings >= 0 && result.warningCount > maxWarnings) {
-      printCliError(
-        `Exceeded maximum warnings: ${result.warningCount} warning${result.warningCount === 1 ? "" : "s"} (limit ${maxWarnings})`
-      );
-      console.error(import_picocolors8.default.dim("Next: fix warnings or raise --max-warnings."));
-      process.exitCode = 1;
-    }
-    return;
-  }
-  if (cmd === "ids") {
-    const rest = args.slice(1);
-    const patterns = rest.filter((arg) => !arg.startsWith("-"));
-    const resolvedPatterns = patterns.length ? patterns : ["**/*.collie"];
-    try {
-      await runIds(resolvedPatterns);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      printCliError(message);
-      process.exit(1);
-    }
-    return;
-  }
-  if (cmd === "explain") {
-    const rest = args.slice(1);
-    const { id, patterns } = parseExplainArgs(rest);
-    if (!id) {
-      throw new Error("No template id provided. Usage: collie explain <id> [files...]");
-    }
-    const resolvedPatterns = patterns.length ? patterns : ["**/*.collie"];
-    try {
-      await runExplain(id, resolvedPatterns);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      printCliError(message);
-      process.exit(1);
-    }
-    return;
-  }
-  if (cmd === "config") {
-    const rest = args.slice(1);
-    const shouldPrint = hasFlag(rest, "--print");
-    if (!shouldPrint) {
-      throw new Error('Missing required flag: --print (e.g. "collie config --print").');
-    }
-    const filePath = getFlag(rest, "--file");
-    const cwdFlag = getFlag(rest, "--cwd");
-    const cwd = cwdFlag ? import_node_path9.default.resolve(process.cwd(), cwdFlag) : filePath ? import_node_path9.default.dirname(import_node_path9.default.resolve(process.cwd(), filePath)) : process.cwd();
-    let loadAndNormalizeConfig;
-    try {
-      ({ loadAndNormalizeConfig } = await import("@collie-lang/config"));
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to load @collie-lang/config (${message}).`);
-    }
-    const normalized = await loadAndNormalizeConfig({ cwd });
-    if (!normalized) {
-      throw new Error(`No Collie config found under ${cwd}.`);
-    }
-    console.log(JSON.stringify(normalized, null, 2));
-    return;
-  }
-  if (cmd === "create") {
-    const rest = args.slice(1);
-    let projectName;
-    const flagArgs = [];
-    for (const arg of rest) {
-      if (!projectName && !arg.startsWith("-")) {
-        projectName = arg;
-      } else {
-        flagArgs.push(arg);
-      }
-    }
-    const templateListRequested = hasFlag(flagArgs, "--list-templates");
-    if (templateListRequested) {
-      console.log(import_picocolors8.default.bold("Available templates:\n"));
-      console.log(formatTemplateList());
-      console.log("\nRun collie create <project-name> --template <template> to scaffold with a specific option.\n");
-      return;
-    }
-    const template = getFlag(flagArgs, "--template");
-    const typescriptFlag = hasFlag(flagArgs, "--typescript");
-    const javascriptFlag = hasFlag(flagArgs, "--javascript");
-    if (typescriptFlag && javascriptFlag) {
-      throw new Error("Use only one of --typescript or --javascript.");
-    }
-    const options = {
-      projectName,
-      template,
-      typescript: typescriptFlag ? true : javascriptFlag ? false : void 0,
-      packageManager: getFlag(flagArgs, "--package-manager"),
-      noInstall: hasFlag(flagArgs, "--no-install"),
-      noGit: hasFlag(flagArgs, "--no-git")
-    };
-    await create(options);
-    return;
-  }
-  if (cmd === "convert") {
-    const rest = args.slice(1);
-    const patterns = rest.filter((arg) => !arg.startsWith("-"));
-    if (patterns.length === 0) {
-      throw new Error("No files provided. Usage: collie convert <files...>");
-    }
-    const write = hasFlag(rest, "--write", "-w");
-    const overwrite = hasFlag(rest, "--overwrite");
-    const removeOriginal = hasFlag(rest, "--remove-original");
-    if (removeOriginal && !write) {
-      throw new Error("--remove-original can only be used with --write.");
-    }
-    const files = await (0, import_fast_glob4.default)(patterns, {
-      absolute: false,
-      onlyFiles: true,
-      unique: true
-    });
-    if (!files.length) {
-      printSummary("warning", "No files matched the provided patterns", void 0, "check the paths and try again");
-      return;
-    }
-    files.sort();
-    const options = { write, overwrite, removeOriginal };
-    let converted = 0;
-    let failed = 0;
-    for (const file of files) {
-      try {
-        const result = await convertFile(file, options);
-        if (write) {
-          const target = result.outputPath ?? file.replace(/\.[tj]sx?$/, ".collie");
-          console.log(import_picocolors8.default.green(`\u2714 Converted ${file} \u2192 ${target}`));
-          converted++;
-        } else {
-          console.log(import_picocolors8.default.gray(`// Converted from ${file}
-`));
-          process.stdout.write(result.collie);
-          if (!result.collie.endsWith("\n")) {
-            process.stdout.write("\n");
-          }
-          console.log("");
-        }
-        for (const warning of result.warnings) {
-          console.warn(import_picocolors8.default.yellow(`\u26A0 ${file}: ${warning}`));
-        }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(import_picocolors8.default.red(`\u2716 Failed to convert ${file}: ${message}`));
-        process.exitCode = 1;
-        failed++;
-      }
-    }
-    if (write) {
-      if (failed === 0) {
-        printSummary(
-          "success",
-          `Converted ${converted} file${converted === 1 ? "" : "s"}`,
-          `wrote ${converted} .collie file${converted === 1 ? "" : "s"}`,
-          "review the generated templates or run collie check"
-        );
-      } else {
-        const changeDetail = converted > 0 ? `wrote ${converted} .collie file${converted === 1 ? "" : "s"} before failing` : void 0;
-        printSummary(
-          "error",
-          `Converted ${converted} file${converted === 1 ? "" : "s"} with ${failed} failure${failed === 1 ? "" : "s"}`,
-          changeDetail,
-          "fix the errors above and rerun collie convert"
-        );
-      }
-    }
-    return;
-  }
-  if (cmd === "doctor") {
-    const rest = args.slice(1);
-    const jsonOutput = hasFlag(rest, "--json");
-    const subsystem = getFlag(rest, "--check");
-    const results = await runDoctor({ cwd: process.cwd() });
-    const filtered = filterDiagnostics(results, subsystem);
-    if (subsystem && filtered.length === 0) {
-      printCliError(`Unknown subsystem for --check: ${subsystem}`);
-      console.error(import_picocolors8.default.dim("Next: run collie doctor to list available checks."));
-      process.exit(1);
-    }
-    if (jsonOutput) {
-      console.log(JSON.stringify(filtered, null, 2));
-    } else {
-      printDoctorResults(filtered);
-    }
-    if (filtered.some((result) => result.status === "fail")) {
-      process.exitCode = 1;
-    }
-    return;
-  }
-  if (cmd === "watch") {
-    const watchArgs = args.slice(1);
-    const inputPath = watchArgs[0];
-    if (!inputPath) {
-      throw new Error("No input path provided. Usage: collie watch <path>");
-    }
-    const flagArgs = watchArgs.slice(1);
-    const verboseFlag = hasFlag(flagArgs, "--verbose", "-v");
-    const sourcemapFlag = hasFlag(flagArgs, "--sourcemap");
-    const jsxFlag = getFlag(flagArgs, "--jsx");
-    await watch(inputPath, {
-      outDir: getFlag(flagArgs, "--outDir"),
-      sourcemap: sourcemapFlag ? true : void 0,
-      ext: getFlag(flagArgs, "--ext"),
-      jsxRuntime: jsxFlag ? parseJsxRuntime(jsxFlag) : void 0,
-      verbose: verboseFlag ? true : void 0
-    });
-    return;
-  }
-  if (cmd === "build") {
-    const buildArgs = args.slice(1);
-    const inputPath = buildArgs[0];
-    if (!inputPath) {
-      throw new Error("No input path provided. Usage: collie build <path>");
-    }
-    const flagArgs = buildArgs.slice(1);
-    const verbose = hasFlag(flagArgs, "--verbose", "-v");
-    const quiet = hasFlag(flagArgs, "--quiet", "-q");
-    if (verbose && quiet) {
-      throw new Error("Cannot use --quiet and --verbose together.");
-    }
-    const sourcemapFlag = hasFlag(flagArgs, "--sourcemap");
-    const jsxFlag = getFlag(flagArgs, "--jsx");
-    const result = await build(inputPath, {
-      outDir: getFlag(flagArgs, "--outDir"),
-      sourcemap: sourcemapFlag ? true : void 0,
-      jsxRuntime: jsxFlag ? parseJsxRuntime(jsxFlag) : void 0,
-      verbose: verbose ? true : void 0,
-      quiet: quiet ? true : void 0
-    });
-    if (result.errors.length > 0) {
-      process.exitCode = 1;
-    }
-    return;
-  }
-  if (cmd === "init") {
-    const rest = args.slice(1);
-    const flagsNeedingValue = /* @__PURE__ */ new Set(["--project", "--package-manager", "--framework"]);
-    let pendingFlag = null;
-    let positionalProject;
-    const extraArgs = [];
-    for (const arg of rest) {
-      if (pendingFlag) {
-        pendingFlag = null;
-        continue;
-      }
-      if (arg.startsWith("-")) {
-        if (flagsNeedingValue.has(arg)) {
-          pendingFlag = arg;
-        }
-        continue;
-      }
-      if (!positionalProject) {
-        positionalProject = arg;
-      } else {
-        extraArgs.push(arg);
-      }
-    }
-    if (pendingFlag) {
-      throw new Error(`${pendingFlag} flag expects a value.`);
-    }
-    if (extraArgs.length > 0) {
-      throw new Error(`Unexpected argument(s): ${extraArgs.join(", ")}`);
-    }
-    const frameworkValue = getFlag(rest, "--framework");
-    const framework = (frameworkValue === "vite" || frameworkValue === "nextjs" ? frameworkValue : void 0) ?? (hasFlag(rest, "--nextjs") ? "nextjs" : void 0) ?? (hasFlag(rest, "--vite") ? "vite" : void 0);
-    const typescriptFlag = hasFlag(rest, "--typescript");
-    const javascriptFlag = hasFlag(rest, "--javascript");
-    if (typescriptFlag && javascriptFlag) {
-      throw new Error("Use only one of --typescript or --javascript.");
-    }
-    const packageManagerValue = getFlag(rest, "--package-manager");
-    let packageManager;
-    if (packageManagerValue) {
-      if (packageManagerValue !== "npm" && packageManagerValue !== "yarn" && packageManagerValue !== "pnpm") {
-        throw new Error('Invalid --package-manager value. Use "npm", "yarn", or "pnpm".');
-      }
-      packageManager = packageManagerValue;
-    }
-    const projectName = getFlag(rest, "--project") ?? positionalProject;
-    const initOptions = {
-      framework,
-      projectName,
-      typescript: typescriptFlag ? true : javascriptFlag ? false : void 0,
-      packageManager,
-      noInstall: hasFlag(rest, "--no-install")
-    };
-    try {
-      const shouldContinue = await runPreflight("init", {
-        framework: initOptions.framework,
-        packageManager: initOptions.packageManager
-      });
-      if (!shouldContinue) {
-        return;
-      }
-      await runInit(initOptions);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      printCliError(message);
-      process.exit(1);
-    }
-    return;
-  }
-  printCliError(`Unknown command: ${cmd}`);
-  process.exit(1);
-}
-function printHelp() {
-  console.log(`${import_picocolors8.default.bold("collie")}
-
-Usage:
-  collie <command> [options]
-
-Commands:
-  collie build    Compile .collie templates to output files
-  collie check    Validate .collie templates
-  collie config   Print resolved Collie config (json)
-  collie ids      List template ids and their locations
-  collie explain  Find the file + location for a template id
-  collie format   Format .collie templates
-  collie convert  Convert JSX/TSX to .collie templates
-  collie doctor   Diagnose setup issues
-  collie init     Create a Collie config and wire Vite when possible
-  collie watch    Watch and compile templates
-  collie create   Scaffold a new Collie project
-`);
-}
-async function runIds(patterns) {
-  const scan = await scanTemplates(patterns);
-  const diagnostics = [...scan.diagnostics, ...buildDuplicateDiagnostics(scan.templates)];
-  const errors = diagnostics.filter((diag) => diag.severity === "error");
-  if (diagnostics.length) {
-    printTemplateDiagnostics(diagnostics);
-  }
-  if (errors.length) {
-    process.exitCode = 1;
-    return;
-  }
-  const templates = [...scan.templates].sort((a, b) => {
-    const byId = a.id.localeCompare(b.id);
-    if (byId !== 0) return byId;
-    return a.displayPath.localeCompare(b.displayPath);
-  });
-  if (!templates.length) {
-    printSummary(
-      "warning",
-      "No template ids found",
-      `checked ${scan.files.length} file${scan.files.length === 1 ? "" : "s"}`,
-      "add #id blocks then rerun collie ids"
-    );
-    return;
-  }
-  for (const template of templates) {
-    console.log(`${template.id}  ${formatTemplateLocation2(template)}`);
-  }
-}
-async function runExplain(id, patterns) {
-  const scan = await scanTemplates(patterns);
-  const diagnostics = [...scan.diagnostics, ...buildDuplicateDiagnostics(scan.templates)];
-  const errors = diagnostics.filter((diag) => diag.severity === "error");
-  if (diagnostics.length) {
-    printTemplateDiagnostics(diagnostics);
-  }
-  if (errors.length) {
-    process.exitCode = 1;
-    return;
-  }
-  const matches = scan.templates.filter((template) => template.id === id);
-  if (!matches.length) {
-    const knownIds = Array.from(new Set(scan.templates.map((template) => template.id))).sort();
-    const preview = knownIds.slice(0, 5);
-    const suffix = knownIds.length > preview.length ? "..." : "";
-    const details = preview.length ? `Known ids: ${preview.join(", ")}${suffix}` : "No template ids found.";
-    printCliError(`Unknown template id "${id}". ${details}`);
-    process.exitCode = 1;
-    return;
-  }
-  const sorted = matches.sort((a, b) => a.displayPath.localeCompare(b.displayPath));
-  for (const template of sorted) {
-    console.log(`${template.id}  ${formatTemplateLocation2(template)}`);
-  }
-}
-function parseExplainArgs(args) {
-  let id;
-  const patterns = [];
-  for (const arg of args) {
-    if (arg.startsWith("-")) {
-      continue;
-    }
-    if (!id) {
-      id = arg;
-      continue;
-    }
-    patterns.push(arg);
-  }
-  return { id, patterns };
-}
-function formatTemplateLocation2(template) {
-  const span = template.span;
-  if (span) {
-    return `${template.displayPath}:${span.start.line}:${span.start.col}`;
-  }
-  return template.displayPath;
-}
-function printTemplateDiagnostics(diagnostics) {
-  for (const diag of diagnostics) {
-    const message = formatDiagnosticLine(diag);
-    const writer = diag.severity === "warning" ? import_picocolors8.default.yellow : import_picocolors8.default.red;
-    console.log(writer(message));
-  }
-  if (diagnostics.length) {
-    console.log("");
-  }
-}
-async function runInit(options = {}) {
-  const projectRoot = process.cwd();
-  const packageJson = await readProjectPackage(projectRoot);
-  const detectedFramework = packageJson ? detectFrameworkFromPackage(packageJson) : null;
-  const cssDetection = await detectCssStrategy(projectRoot, packageJson);
-  const framework = options.framework ?? detectedFramework;
-  const projectType = framework ? mapFrameworkToProjectType(framework) : await promptProjectType();
-  const existingConfig = findExistingCollieConfig(projectRoot);
-  const targetPath = existingConfig ?? import_node_path9.default.join(projectRoot, "collie.config.ts");
-  const relativeTarget = import_node_path9.default.relative(projectRoot, targetPath) || import_node_path9.default.basename(targetPath);
-  console.log(import_picocolors8.default.bold("collie init"));
-  console.log(import_picocolors8.default.dim("This creates a Collie config and applies framework wiring when possible."));
-  if (framework) {
-    console.log(import_picocolors8.default.dim(`Detected ${formatFrameworkLabel(framework)} project.`));
-  } else {
-    console.log(import_picocolors8.default.dim("No framework detected."));
-  }
-  console.log(import_picocolors8.default.dim(`CSS strategy: ${formatCssDetection(cssDetection)}.`));
-  console.log(import_picocolors8.default.dim(`Override in ${relativeTarget} via css.strategy and css.diagnostics.unknownClass.`));
-  console.log(import_picocolors8.default.dim(`Project type: ${describeProjectType(projectType)}.`));
-  console.log("");
-  const configLabel = framework === "vite" ? "Vite-ready" : "Collie";
-  const confirmMessage = existingConfig ? `${relativeTarget} already exists. Replace it with a ${configLabel} config?` : `Create ${relativeTarget}?`;
-  const shouldWrite = await promptForConfirmation(confirmMessage, !existingConfig);
-  if (!shouldWrite) {
-    const detail = existingConfig ? `left ${relativeTarget} unchanged` : "no files created";
-    printSummary("warning", "No changes made", detail, "run collie init when you are ready");
-    return;
-  }
-  const contents = buildInitConfig(projectType, import_node_path9.default.extname(targetPath).toLowerCase(), cssDetection);
-  await import_promises9.default.writeFile(targetPath, contents, "utf8");
-  const typeDeclarationsPath = import_node_path9.default.join(projectRoot, "src", "collie.d.ts");
-  let typeDeclarationsStatus = "skipped";
-  if (projectType !== "html" && shouldWriteTypeDeclarations(projectRoot, options)) {
-    if ((0, import_node_fs4.existsSync)(typeDeclarationsPath)) {
-      typeDeclarationsStatus = "exists";
-    } else {
-      await ensureCollieDeclaration(projectRoot);
-      typeDeclarationsStatus = "created";
-    }
-  }
-  let viteConfigStatus = "skipped";
-  let viteConfigPath = null;
-  if (framework === "vite") {
-    viteConfigPath = findViteConfigFile(projectRoot);
-    if (viteConfigPath) {
-      viteConfigStatus = await patchViteConfig(viteConfigPath);
-    } else {
-      viteConfigStatus = "not-found";
-    }
-  }
-  printSummary("success", "Initialized Collie config", `created ${relativeTarget}`);
-  if (typeDeclarationsStatus !== "skipped") {
-    const declarationLabel = import_node_path9.default.relative(projectRoot, typeDeclarationsPath) || import_node_path9.default.basename(typeDeclarationsPath);
-    if (typeDeclarationsStatus === "created") {
-      console.log(import_picocolors8.default.green(`\u2714 Added ${declarationLabel} for .collie typings`));
-    } else {
-      console.log(import_picocolors8.default.dim(`- ${declarationLabel} already exists`));
-    }
-  } else if (projectType !== "html") {
-    console.log(
-      import_picocolors8.default.dim("Skipping .collie typings (no TypeScript config found). Add src/collie.d.ts if you enable TypeScript.")
-    );
-  }
-  if (framework === "vite") {
-    if (viteConfigStatus === "patched" && viteConfigPath) {
-      console.log(import_picocolors8.default.green(`\u2714 Updated ${import_node_path9.default.relative(projectRoot, viteConfigPath) || import_node_path9.default.basename(viteConfigPath)}`));
-    } else if (viteConfigStatus === "already-configured" && viteConfigPath) {
-      console.log(
-        import_picocolors8.default.dim(`- ${import_node_path9.default.relative(projectRoot, viteConfigPath) || import_node_path9.default.basename(viteConfigPath)} already includes collie()`)
-      );
-    } else if (viteConfigStatus === "manual" && viteConfigPath) {
-      console.log(
-        import_picocolors8.default.yellow(
-          `\u26A0 Could not patch ${import_node_path9.default.relative(projectRoot, viteConfigPath) || import_node_path9.default.basename(viteConfigPath)}. Add collie() manually to the Vite plugins array.`
-        )
-      );
-    } else if (viteConfigStatus === "not-found") {
-      console.log(import_picocolors8.default.yellow("\u26A0 Vite config not found. Add the Collie plugin to vite.config.ts manually."));
-    }
-  }
-  if (framework === "vite") {
-    const pkgManager = options.packageManager ?? detectPackageManager2(projectRoot);
-    printNextSteps(pkgManager, targetPath);
-  }
-  if (!framework) {
-    console.log(import_picocolors8.default.dim(`Tip: update the project type in ${relativeTarget} if needed.`));
-  }
-}
-async function readProjectPackage(projectRoot) {
-  const packageJsonPath = import_node_path9.default.join(projectRoot, "package.json");
-  if (!(0, import_node_fs4.existsSync)(packageJsonPath)) {
-    return null;
-  }
-  const raw = await import_promises9.default.readFile(packageJsonPath, "utf8");
-  return JSON.parse(raw);
-}
-function detectFrameworkFromPackage(pkg) {
-  if (hasNextDependency(pkg)) {
-    return "nextjs";
-  }
-  if (getViteDependencyInfo(pkg)) {
-    return "vite";
-  }
-  return null;
-}
-function mapFrameworkToProjectType(framework) {
-  return framework === "nextjs" ? "react-next" : "react-vite";
-}
-function formatFrameworkLabel(framework) {
-  return framework === "nextjs" ? "Next.js" : "Vite";
-}
-function describeProjectType(projectType) {
-  const labels = {
-    "react-vite": "React (Vite)",
-    "react-next": "React (Next.js)",
-    "react-generic": "React (generic)",
-    html: "HTML (no framework)"
-  };
-  return labels[projectType];
-}
-function shouldWriteTypeDeclarations(projectRoot, options) {
-  if (options.typescript === false) {
-    return false;
-  }
-  if (options.typescript === true) {
-    return true;
-  }
-  return (0, import_node_fs4.existsSync)(import_node_path9.default.join(projectRoot, "tsconfig.json"));
-}
-async function detectCssStrategy(projectRoot, packageJson) {
-  const reasons = [];
-  try {
-    let tailwindDetected = false;
-    for (const filename of TAILWIND_CONFIG_FILES) {
-      if ((0, import_node_fs4.existsSync)(import_node_path9.default.join(projectRoot, filename))) {
-        reasons.push(`${filename} found`);
-        tailwindDetected = true;
-      }
-    }
-    if (packageJson && hasTailwindDependency(packageJson)) {
-      reasons.push("package.json includes tailwindcss");
-      tailwindDetected = true;
-    }
-    const postcssHit = await scanPostcssForTailwind(projectRoot);
-    if (postcssHit) {
-      reasons.push(`${postcssHit} mentions tailwindcss`);
-      tailwindDetected = true;
-    }
-    const cssHit = await scanTopLevelCssForTailwind(projectRoot);
-    if (cssHit) {
-      reasons.push(`${cssHit} contains @tailwind`);
-      tailwindDetected = true;
-    }
-    if (tailwindDetected) {
-      return { strategy: "tailwind", unknownClass: "off", reasons };
-    }
-    return {
-      strategy: "global",
-      unknownClass: "warn",
-      reasons: ["no Tailwind signals found"]
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      strategy: "unknown",
-      unknownClass: "off",
-      reasons: [`detection error: ${message}`]
-    };
-  }
-}
-function formatCssDetection(result) {
-  const reason = result.reasons.length ? ` (${result.reasons.join(", ")})` : "";
-  const label = result.strategy === "tailwind" ? "Tailwind" : result.strategy === "global" ? "Global CSS" : "Unknown";
-  return `${label}${reason} => unknownClass ${result.unknownClass}`;
-}
-function hasTailwindDependency(pkg) {
-  return Boolean(
-    pkg.dependencies && pkg.dependencies.tailwindcss || pkg.devDependencies && pkg.devDependencies.tailwindcss || pkg.peerDependencies && pkg.peerDependencies.tailwindcss
-  );
-}
-async function scanPostcssForTailwind(projectRoot) {
-  for (const filename of POSTCSS_CONFIG_FILES) {
-    const fullPath = import_node_path9.default.join(projectRoot, filename);
-    if (!(0, import_node_fs4.existsSync)(fullPath)) {
-      continue;
-    }
-    const contents = await import_promises9.default.readFile(fullPath, "utf8");
-    if (contents.includes("tailwindcss")) {
-      return filename;
-    }
-  }
-  return null;
-}
-async function scanTopLevelCssForTailwind(projectRoot) {
-  const files = await (0, import_fast_glob4.default)("*.css", { cwd: projectRoot, onlyFiles: true });
-  for (const filename of files) {
-    const fullPath = import_node_path9.default.join(projectRoot, filename);
-    const contents = await import_promises9.default.readFile(fullPath, "utf8");
-    if (/\@tailwind\s+(base|components|utilities)\b/.test(contents)) {
-      return filename;
-    }
-  }
-  return null;
-}
-function buildInitConfig(projectType, ext, cssDetection) {
-  const config = {
-    css: {
-      strategy: cssDetection.strategy,
-      diagnostics: {
-        unknownClass: cssDetection.unknownClass
-      }
-    },
-    projects: [
-      {
-        type: projectType,
-        input: "src/**/*.collie"
-      }
-    ]
-  };
-  if (ext === ".json") {
-    return `${JSON.stringify(config, null, 2)}
-`;
-  }
-  const commentLines = projectType === "react-vite" ? [
-    "// Collie config for Vite.",
-    "// Templates are compiled in-memory by @collie-lang/vite."
-  ] : ["// Collie config. Update the project type or input as needed."];
-  const comment = `${commentLines.join("\n")}
-`;
-  const body = JSON.stringify(config, null, 2);
-  if (ext === ".mjs" || ext === ".ts") {
-    return `${comment}export default ${body};
-`;
-  }
-  return `${comment}module.exports = ${body};
-`;
-}
-function findExistingCollieConfig(root) {
-  for (const filename of COLLIE_CONFIG_FILES) {
-    const candidate = import_node_path9.default.join(root, filename);
-    if ((0, import_node_fs4.existsSync)(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-async function promptForConfirmation(message, initial) {
-  const response = await (0, import_prompts2.default)(
-    {
-      type: "confirm",
-      name: "confirmed",
-      message,
-      initial
-    },
-    PROMPT_OPTIONS
-  );
-  return Boolean(response.confirmed);
-}
-async function promptProjectType() {
-  const response = await (0, import_prompts2.default)(
-    {
-      type: "select",
-      name: "projectType",
-      message: "What type of project should this config describe?",
-      choices: [
-        { title: "React (Vite)", value: "react-vite" },
-        { title: "React (Next.js)", value: "react-next" },
-        { title: "React (generic)", value: "react-generic" },
-        { title: "HTML (no framework)", value: "html" }
-      ],
-      initial: 0
-    },
-    PROMPT_OPTIONS
-  );
-  return response.projectType ?? "react-generic";
-}
-async function runPreflight(command, options = {}) {
-  if (preflightCompleted) {
-    return true;
-  }
-  preflightCompleted = true;
-  const projectRoot = findProjectRoot(process.cwd());
-  if (!projectRoot) {
-    console.log(import_picocolors8.default.dim("Skipping dependency preflight (no package.json found)."));
-    return true;
-  }
-  let packageJson = null;
-  try {
-    packageJson = await readProjectPackage(projectRoot);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.log(import_picocolors8.default.yellow(`Skipping dependency preflight: failed to read package.json (${message}).`));
-    return true;
-  }
-  if (!packageJson) {
-    console.log(import_picocolors8.default.dim("Skipping dependency preflight (package.json not found)."));
-    return true;
-  }
-  const detectedFramework = detectFrameworkFromPackage(packageJson);
-  const resolvedFramework = options.framework ?? detectedFramework ?? (command === "init" ? "vite" : void 0);
-  const requiredPackages = getRequiredPackages(command, resolvedFramework);
-  if (requiredPackages.length === 0) {
-    return true;
-  }
-  const missing = collectMissingDependencies(projectRoot, packageJson, requiredPackages);
-  if (missing.length === 0) {
-    return true;
-  }
-  const packageManager = options.packageManager ?? detectPackageManager2(projectRoot);
-  const prompt = `Missing required Collie packages: ${missing.join(", ")}. Install now?`;
-  const shouldInstall = await promptForConfirmation(prompt, true);
-  if (!shouldInstall) {
-    console.log(import_picocolors8.default.yellow("Skipped installing Collie dependencies."));
-    console.log(
-      import_picocolors8.default.dim(`Next: ${formatInstallCommand(packageManager, missing)} && collie ${command}`)
-    );
-    return false;
-  }
-  const specs = missing.map((dep) => resolveDependencySpec(dep));
-  console.log(import_picocolors8.default.cyan(`Installing ${missing.length} Collie package${missing.length === 1 ? "" : "s"}...`));
-  await installDevDependencies(packageManager, projectRoot, specs);
-  console.log(import_picocolors8.default.green(`\u2714 Installed ${missing.length} Collie package${missing.length === 1 ? "" : "s"}.`));
-  return true;
-}
-function findProjectRoot(startDir) {
-  let current = startDir;
-  while (true) {
-    if ((0, import_node_fs4.existsSync)(import_node_path9.default.join(current, "package.json"))) {
-      return current;
-    }
-    const parent = import_node_path9.default.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-function getRequiredPackages(command, framework) {
-  if (command === "check") {
-    return ["@collie-lang/compiler"];
-  }
-  if (framework === "nextjs") {
-    return [...COLLIE_NEXT_PACKAGES];
-  }
-  if (framework === "vite") {
-    return [...COLLIE_VITE_PACKAGES];
-  }
-  return [...COLLIE_CORE_PACKAGES];
-}
-function collectMissingDependencies(projectRoot, packageJson, required) {
-  return required.filter((dependency) => !isDependencySatisfied(projectRoot, packageJson, dependency));
-}
-function isDependencySatisfied(projectRoot, packageJson, dependency) {
-  const listed = Boolean(
-    packageJson?.dependencies?.[dependency] || packageJson?.devDependencies?.[dependency]
-  );
-  if (listed) {
-    return true;
-  }
-  const modulePath = import_node_path9.default.join(projectRoot, "node_modules", ...dependency.split("/"));
-  return (0, import_node_fs4.existsSync)(modulePath);
-}
-function resolveDependencySpec(packageName) {
-  const range = normalizeDependencyRange(CLI_DEPENDENCY_SPECS[packageName], "latest");
-  return `${packageName}@${range}`;
-}
-function formatInstallCommand(packageManager, dependencies) {
-  const specs = dependencies.map((dep) => resolveDependencySpec(dep));
-  if (packageManager === "pnpm") {
-    return `pnpm add -D ${specs.join(" ")}`;
-  }
-  if (packageManager === "yarn") {
-    return `yarn add -D ${specs.join(" ")}`;
-  }
-  return `npm install -D ${specs.join(" ")}`;
-}
-function detectPackageManager2(root) {
-  if ((0, import_node_fs4.existsSync)(import_node_path9.default.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if ((0, import_node_fs4.existsSync)(import_node_path9.default.join(root, "yarn.lock"))) return "yarn";
-  return "npm";
-}
-async function installDevDependencies(packageManager, cwd, deps) {
-  const argsByManager = {
-    pnpm: ["add", "-D", ...deps],
-    yarn: ["add", "-D", ...deps],
-    npm: ["install", "-D", ...deps]
-  };
-  await runCommand2(packageManager, argsByManager[packageManager], cwd);
-}
-async function patchViteConfig(configPath) {
-  const original = await import_promises9.default.readFile(configPath, "utf8");
-  const hasImport = original.includes("@collie-lang/vite");
-  const hasPlugin = /\bcollie\s*\(/.test(original);
-  if (hasImport && hasPlugin) {
-    return "already-configured";
-  }
-  try {
-    const result = transformViteConfig(original);
-    if (!result.changed) {
-      return "already-configured";
-    }
-    await import_promises9.default.writeFile(configPath, result.code, "utf8");
-    return "patched";
-  } catch (error) {
-    return "manual";
-  }
-}
-function transformViteConfig(source) {
-  const sourceFile = import_typescript.default.createSourceFile(
-    "vite.config.ts",
-    source,
-    import_typescript.default.ScriptTarget.Latest,
-    true,
-    import_typescript.default.ScriptKind.TS
-  );
-  let needsImport = !source.includes("@collie-lang/vite");
-  let needsPlugin = !/\bcollie\s*\(/.test(source);
-  let changed = false;
-  const printer = import_typescript.default.createPrinter({ newLine: import_typescript.default.NewLineKind.LineFeed });
-  const transformer = (context) => {
-    return (rootNode) => {
-      function visit(node) {
-        if (needsImport && import_typescript.default.isImportDeclaration(node)) {
-          return node;
-        }
-        if (import_typescript.default.isCallExpression(node) && import_typescript.default.isIdentifier(node.expression) && node.expression.text === "defineConfig" && node.arguments.length > 0) {
-          const configArg = node.arguments[0];
-          if (import_typescript.default.isObjectLiteralExpression(configArg)) {
-            const updatedConfig = updateConfigObject(configArg);
-            if (updatedConfig !== configArg) {
-              changed = true;
-              return import_typescript.default.factory.updateCallExpression(
-                node,
-                node.expression,
-                node.typeArguments,
-                [updatedConfig]
-              );
-            }
-          }
-        }
-        return import_typescript.default.visitEachChild(node, visit, context);
-      }
-      function updateConfigObject(configObj) {
-        let pluginsProperty;
-        const otherProperties = [];
-        for (const prop of configObj.properties) {
-          if (import_typescript.default.isPropertyAssignment(prop) && import_typescript.default.isIdentifier(prop.name) && prop.name.text === "plugins") {
-            pluginsProperty = prop;
-          } else {
-            otherProperties.push(prop);
-          }
-        }
-        let updatedPluginsArray;
-        if (pluginsProperty && import_typescript.default.isArrayLiteralExpression(pluginsProperty.initializer)) {
-          updatedPluginsArray = ensurePluginOrdering(pluginsProperty.initializer);
-          if (updatedPluginsArray === pluginsProperty.initializer) {
-            return configObj;
-          }
-        } else if (needsPlugin) {
-          updatedPluginsArray = import_typescript.default.factory.createArrayLiteralExpression(
-            [createCollieCall()],
-            false
-          );
-        } else {
-          return configObj;
-        }
-        const updatedPluginsProperty = import_typescript.default.factory.createPropertyAssignment(
-          "plugins",
-          updatedPluginsArray
-        );
-        if (pluginsProperty) {
-          const allProperties = [...otherProperties, updatedPluginsProperty];
-          return import_typescript.default.factory.updateObjectLiteralExpression(configObj, allProperties);
-        } else {
-          const allProperties = [...otherProperties, updatedPluginsProperty];
-          return import_typescript.default.factory.updateObjectLiteralExpression(configObj, allProperties);
-        }
-      }
-      function ensurePluginOrdering(array) {
-        const elements = Array.from(array.elements);
-        let hasReact = false;
-        let hasCollie = false;
-        let reactIndex = -1;
-        let collieIndex = -1;
-        elements.forEach((elem, idx) => {
-          if (import_typescript.default.isCallExpression(elem) && import_typescript.default.isIdentifier(elem.expression)) {
-            if (elem.expression.text === "react") {
-              hasReact = true;
-              reactIndex = idx;
-            } else if (elem.expression.text === "collie") {
-              hasCollie = true;
-              collieIndex = idx;
-            }
-          }
-        });
-        const isMultiLine = elements.length > 1;
-        if (hasCollie && !needsPlugin) {
-          if (hasReact && reactIndex > collieIndex) {
-            const newElements = [...elements];
-            const reactPlugin = newElements[reactIndex];
-            const colliePlugin = newElements[collieIndex];
-            newElements[collieIndex] = reactPlugin;
-            newElements[reactIndex] = colliePlugin;
-            return import_typescript.default.factory.createArrayLiteralExpression(newElements, isMultiLine);
-          }
-          return array;
-        }
-        if (!hasCollie && needsPlugin) {
-          const newElements = [...elements, createCollieCall()];
-          return import_typescript.default.factory.createArrayLiteralExpression(newElements, isMultiLine);
-        }
-        return array;
-      }
-      function createCollieCall() {
-        return import_typescript.default.factory.createCallExpression(
-          import_typescript.default.factory.createIdentifier("collie"),
-          void 0,
-          []
-        );
-      }
-      const visited = import_typescript.default.visitNode(rootNode, visit);
-      if (needsImport && changed) {
-        const collieImport = import_typescript.default.factory.createImportDeclaration(
-          void 0,
-          import_typescript.default.factory.createImportClause(
-            false,
-            import_typescript.default.factory.createIdentifier("collie"),
-            void 0
-          ),
-          import_typescript.default.factory.createStringLiteral("@collie-lang/vite", true)
-        );
-        let lastImportIndex = -1;
-        for (let i = 0; i < visited.statements.length; i++) {
-          if (import_typescript.default.isImportDeclaration(visited.statements[i])) {
-            lastImportIndex = i;
-          }
-        }
-        const statements = Array.from(visited.statements);
-        if (lastImportIndex >= 0) {
-          statements.splice(lastImportIndex + 1, 0, collieImport);
-        } else {
-          statements.unshift(collieImport);
-        }
-        return import_typescript.default.factory.updateSourceFile(visited, statements);
-      }
-      return visited;
-    };
-  };
-  const result = import_typescript.default.transform(sourceFile, [transformer]);
-  const transformedSourceFile = result.transformed[0];
-  result.dispose();
-  if (!changed) {
-    return { code: source, changed: false };
-  }
-  const output = printer.printFile(transformedSourceFile);
-  return { code: output, changed: true };
-}
-async function ensureCollieDeclaration(root) {
-  const target = import_node_path9.default.join(root, "src", "collie.d.ts");
-  if ((0, import_node_fs4.existsSync)(target)) return;
-  await import_promises9.default.mkdir(import_node_path9.default.dirname(target), { recursive: true });
-  const declaration = `// Allows importing Collie templates as React components.
-// Customize this typing if your templates expose specific props.
-declare module "*.collie" {
-  import type { ComponentType } from "react";
-  const component: ComponentType<Record<string, unknown>>;
-  export default component;
-}
-`;
-  await import_promises9.default.writeFile(target, declaration, "utf8");
-}
-function findViteConfigFile(root) {
-  for (const file of VITE_CONFIG_FILES2) {
-    const candidate = import_node_path9.default.join(root, file);
-    if ((0, import_node_fs4.existsSync)(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-function readCliPackageInfo() {
-  try {
-    const dir = import_node_path9.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
-    const pkgPath = import_node_path9.default.resolve(dir, "..", "package.json");
-    const raw = (0, import_node_fs4.readFileSync)(pkgPath, "utf8");
-    const pkg = JSON.parse(raw);
-    const version = typeof pkg.version === "string" ? pkg.version : "latest";
-    const dependencies = pkg && typeof pkg === "object" && pkg.dependencies && typeof pkg.dependencies === "object" ? pkg.dependencies : {};
-    return { version, dependencies };
-  } catch {
-    return { version: "latest", dependencies: {} };
-  }
-}
-function formatCollieDependency(packageName) {
-  return CLI_PACKAGE_VERSION === "latest" ? packageName : `${packageName}@${CLI_PACKAGE_VERSION}`;
-}
-function normalizeDependencyRange(spec, fallback) {
-  if (!spec) {
-    return fallback;
-  }
-  if (spec.startsWith("workspace:")) {
-    const trimmed = spec.replace(/^workspace:/, "");
-    return trimmed && trimmed !== "*" ? trimmed : fallback;
-  }
-  return spec;
-}
-function getViteDependencyInfo(pkg) {
-  const spec = pkg.devDependencies && pkg.devDependencies.vite || pkg.dependencies && pkg.dependencies.vite || null;
-  if (!spec) return null;
-  const normalized = spec.replace(/^workspace:/, "").replace(/^[~^>=<\s]*/, "");
-  const match = normalized.match(/(\d+)(?:\.\d+)?/);
-  return { range: spec, major: match ? Number(match[1]) : null };
-}
-function printNextSteps(pkgManager, configPath) {
-  const devCommand = formatDevCommand(pkgManager);
-  console.log("");
-  console.log(import_picocolors8.default.green("Next steps:"));
-  console.log(`  - Create a Collie template under src (e.g. src/Hello.collie).`);
-  console.log(`  - Import it in your React app and run ${devCommand} to start Vite.`);
-  console.log(`  - Need to adjust plugins later? Edit ${import_node_path9.default.basename(configPath)}.`);
-}
-function formatDevCommand(pkgManager) {
-  if (pkgManager === "pnpm") return "pnpm dev";
-  if (pkgManager === "yarn") return "yarn dev";
-  return "npm run dev";
-}
-function runCommand2(command, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = (0, import_node_child_process2.spawn)(command, args, { cwd, stdio: "inherit" });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
-    });
-  });
-}
-async function runFormat(args) {
-  const { patterns, flags } = parseFormatArgs(args);
-  if (patterns.length === 0) {
-    throw new Error("No file patterns provided. Usage: collie format <files...>");
-  }
-  const indent = flags.indent ?? 2;
-  const cwd = process.cwd();
-  const files = await (0, import_fast_glob4.default)(patterns, { cwd, onlyFiles: true, unique: true });
-  if (!files.length) {
-    printSummary("warning", "No files matched the provided patterns", void 0, "check the glob and try again");
-    return;
-  }
-  files.sort();
-  let written = 0;
-  let needsFormatting = 0;
-  let failures = 0;
-  for (const file of files) {
-    let contents;
-    try {
-      contents = await import_promises9.default.readFile(file, "utf8");
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(import_picocolors8.default.red(`\u2716 Failed to read ${file}: ${message}`));
-      failures++;
-      continue;
-    }
-    let result;
-    try {
-      result = formatSource(contents, { indent });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(import_picocolors8.default.red(`\u2716 Failed to format ${file}: ${message}`));
-      failures++;
-      continue;
-    }
-    if (!result.success) {
-      printDiagnostics(file, result.diagnostics);
-      failures++;
-      continue;
-    }
-    const changed = result.formatted !== contents;
-    if (flags.diff && changed) {
-      printDiff(file, contents, result.formatted);
-    }
-    if (flags.check) {
-      if (changed) {
-        console.log(import_picocolors8.default.red(`\u2716 ${file} needs formatting`));
-        needsFormatting++;
-      } else {
-        console.log(import_picocolors8.default.green(`\u2714 ${file} is formatted`));
-      }
-      continue;
-    }
-    if (flags.write) {
-      if (changed) {
-        await import_promises9.default.writeFile(file, result.formatted, "utf8");
-        written++;
-        console.log(import_picocolors8.default.green(`\u2714 Formatted ${file}`));
-      } else {
-        console.log(import_picocolors8.default.dim(`- ${file} already formatted`));
-      }
-      continue;
-    }
-    if (!flags.diff) {
-      process.stdout.write(result.formatted);
-    }
-  }
-  if (flags.check) {
-    if (needsFormatting > 0) {
-      console.log("");
-      printSummary(
-        "error",
-        `${needsFormatting} file${needsFormatting === 1 ? "" : "s"} need formatting`,
-        "no files changed"
-      );
-      console.log(import_picocolors8.default.dim("Run: collie format --write to fix"));
-      process.exitCode = 1;
-    } else if (failures > 0) {
-      printSummary(
-        "error",
-        `Failed to check ${failures} file${failures === 1 ? "" : "s"}`,
-        "no files changed",
-        "resolve the errors above and rerun collie format --check"
-      );
-    } else {
-      printSummary(
-        "success",
-        `All ${files.length} file${files.length === 1 ? "" : "s"} formatted`,
-        "no files changed",
-        "run collie build when you are ready to compile"
-      );
-    }
-  } else if (flags.write) {
-    if (failures > 0) {
-      printSummary(
-        "error",
-        `Formatted ${written} file${written === 1 ? "" : "s"} with ${failures} failure${failures === 1 ? "" : "s"}`,
-        `wrote ${written} file${written === 1 ? "" : "s"} to disk`,
-        "fix the errors above and rerun collie format --write"
-      );
-    } else {
-      printSummary(
-        "success",
-        `Formatted ${written} file${written === 1 ? "" : "s"}`,
-        `wrote ${written} file${written === 1 ? "" : "s"} to disk`,
-        "review the changes or run collie check"
-      );
-    }
-  }
-  if (failures > 0) {
-    process.exitCode = 1;
-  }
-}
-function parseFormatArgs(args) {
-  const flags = { write: false, check: false, diff: false };
-  const patterns = [];
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--write" || arg === "-w") {
-      flags.write = true;
-      continue;
-    }
-    if (arg === "--check" || arg === "-c") {
-      flags.check = true;
-      continue;
-    }
-    if (arg === "--diff" || arg === "-d") {
-      flags.diff = true;
-      continue;
-    }
-    if (arg === "--indent") {
-      const value = args[i + 1];
-      if (!value) {
-        throw new Error("--indent flag expects a number.");
-      }
-      const parsed = Number(value);
-      if (!Number.isFinite(parsed) || parsed < 1) {
-        throw new Error("Indent width must be a positive integer.");
-      }
-      flags.indent = Math.floor(parsed);
-      i++;
-      continue;
-    }
-    if (arg.startsWith("-")) {
-      throw new Error(`Unknown option: ${arg}`);
-    }
-    patterns.push(arg);
-  }
-  if (flags.write && flags.check) {
-    throw new Error("Cannot use --write and --check together.");
-  }
-  return { patterns, flags };
-}
-function printDiagnostics(file, diagnostics) {
-  for (const diag of diagnostics) {
-    const message = formatDiagnosticLine({ ...diag, file }, file);
-    if (diag.severity === "warning") {
-      console.warn(import_picocolors8.default.yellow(message));
-    } else {
-      console.error(import_picocolors8.default.red(message));
-    }
-  }
-}
-function printDiff(file, before, after) {
-  console.log(import_picocolors8.default.cyan(`diff -- ${file}`));
-  const diff = (0, import_diff.diffLines)(before, after);
-  for (const part of diff) {
-    const prefix = part.added ? "+" : part.removed ? "-" : " ";
-    const color = part.added ? import_picocolors8.default.green : part.removed ? import_picocolors8.default.red : import_picocolors8.default.dim;
-    const lines = part.value.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      if (i === lines.length - 1 && line === "") {
-        continue;
-      }
-      console.log(color(`${prefix}${line}`));
-    }
-  }
-}
-function getFlag(args, flag) {
-  const index = args.indexOf(flag);
-  if (index === -1) {
-    return void 0;
-  }
-  const value = args[index + 1];
-  if (!value || value.startsWith("-")) {
-    throw new Error(`${flag} flag expects a value.`);
-  }
-  return value;
-}
-function hasFlag(args, ...names) {
-  return names.some((name) => args.includes(name));
-}
-function parseJsxRuntime(value) {
-  if (!value) {
-    throw new Error("--jsx flag expects a value.");
-  }
-  if (value === "automatic" || value === "classic") {
-    return value;
-  }
-  throw new Error('Invalid --jsx flag. Use "automatic" or "classic".');
-}
-function validateFormatFlag(value) {
-  if (value === "text" || value === "json") {
-    return value;
-  }
-  throw new Error('Invalid --format flag. Use "text" or "json".');
-}
-function printCliError(message) {
-  console.error(import_picocolors8.default.red(`\u2716 ${message}`));
-}
-main().catch((error) => {
-  printCliError(error instanceof Error ? error.message : String(error));
-  process.exit(1);
-});
-//# sourceMappingURL=index.cjs.map