@ansh-ui/cli 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ansh contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli.js

@@ -0,0 +1,680 @@
+#!/usr/bin/env node
+import { parseArgs } from 'util';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { parseColor, generatePalette, rgbToOklch, toOklchString, toHex, createGradient, createScale, checkContrast, harmony, effects, behaviours } from '@ansh-ui/core';
+
+function findRoot(cwd) {
+  let current = resolve(cwd);
+  for (let depth = 0; depth < 10; depth++) {
+    if (existsSync(join(current, "package.json"))) return current;
+    const parent = resolve(current, "..");
+    if (parent === current) break;
+    current = parent;
+  }
+  return resolve(cwd);
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function detectProject(cwd = process.cwd()) {
+  const root = findRoot(cwd);
+  const pkg = readJson(join(root, "package.json")) ?? {};
+  const deps = {
+    ...pkg.dependencies ?? {},
+    ...pkg.devDependencies ?? {}
+  };
+  const framework = deps.nuxt ? "nuxt" : deps.next ? "next" : deps.vue ? "vue" : deps.react ? "react" : "unknown";
+  const typescript = Boolean(deps.typescript) || existsSync(join(root, "tsconfig.json"));
+  const packageManager = existsSync(join(root, "pnpm-lock.yaml")) ? "pnpm" : existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock")) ? "bun" : existsSync(join(root, "yarn.lock")) ? "yarn" : "npm";
+  return {
+    root,
+    framework,
+    typescript,
+    componentsDir: detectComponentsDir(root, framework),
+    alias: detectAlias(root),
+    packageManager,
+    installed: Boolean(
+      deps["@ansh-ui/react"] || deps["@ansh-ui/vue"] || deps["@ansh-ui/nuxt"] || deps["@ansh-ui/core"]
+    )
+  };
+}
+function detectComponentsDir(root, framework) {
+  const candidates = framework === "nuxt" ? ["components", "app/components", "src/components"] : ["src/components", "components", "app/components", "src/lib/components", "app/ui", "src/ui"];
+  for (const candidate of candidates) {
+    if (existsSync(join(root, candidate))) return candidate;
+  }
+  if (existsSync(join(root, "src"))) return "src/components";
+  if (framework === "nuxt") return "components";
+  return "components";
+}
+function detectAlias(root) {
+  for (const file of ["tsconfig.json", "jsconfig.json"]) {
+    const config = readJson(join(root, file));
+    if (!config) continue;
+    const compilerOptions = config.compilerOptions;
+    const paths = compilerOptions?.paths;
+    if (!paths) continue;
+    for (const pattern of Object.keys(paths)) {
+      if (pattern.endsWith("/*")) return pattern.slice(0, -1);
+    }
+  }
+  return null;
+}
+function installCommand(info, packages) {
+  const list = packages.join(" ");
+  switch (info.packageManager) {
+    case "pnpm":
+      return `pnpm add ${list}`;
+    case "yarn":
+      return `yarn add ${list}`;
+    case "bun":
+      return `bun add ${list}`;
+    default:
+      return `npm install ${list}`;
+  }
+}
+var COMPONENT_NAMES = {
+  aurora: "AuroraBackground",
+  "mesh-gradient": "MeshGradient",
+  "animated-gradient": "AnimatedGradient",
+  "particle-field": "ParticleField",
+  constellation: "Constellation",
+  meteors: "MeteorShower",
+  rain: "Rain",
+  snow: "Snow",
+  fireflies: "Fireflies",
+  waves: "Waves",
+  blob: "LiquidBlob",
+  "noise-layer": "NoiseLayer",
+  spotlight: "Spotlight",
+  magnetic: "MagneticButton",
+  tilt: "TiltCard",
+  ripple: "Ripple",
+  marquee: "Marquee",
+  "scroll-reveal": "ScrollReveal",
+  parallax: "Parallax",
+  "split-text": "SplitText"
+};
+function componentNameFor(name) {
+  return COMPONENT_NAMES[name] ?? name.replace(/(^|-)([a-z])/g, (_, __, letter) => letter.toUpperCase());
+}
+function listCatalogue(filter) {
+  const entries = [];
+  if (filter !== "behaviour") {
+    for (const [name, definition] of Object.entries(effects)) {
+      entries.push({
+        name,
+        kind: "effect",
+        component: componentNameFor(name),
+        options: describeOptions(definition.defaults)
+      });
+    }
+  }
+  if (filter !== "effect") {
+    for (const [name, definition] of Object.entries(behaviours)) {
+      entries.push({
+        name,
+        kind: "behaviour",
+        component: componentNameFor(name),
+        options: describeOptions(definition.defaults)
+      });
+    }
+  }
+  return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+function describeOptions(defaults) {
+  return Object.entries(defaults).map(([name, value]) => ({ name, default: value })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function findEntry(query) {
+  const needle = query.toLowerCase();
+  return listCatalogue().find(
+    (entry) => entry.name.toLowerCase() === needle || entry.component.toLowerCase() === needle
+  );
+}
+
+// src/commands/add.ts
+function addComponent(options) {
+  const project = detectProject(options.cwd);
+  const entry = findEntry(options.name);
+  if (!entry) {
+    throw new Error(
+      `Unknown component "${options.name}". Run \`ansh list\` to see what's available.`
+    );
+  }
+  if (project.framework === "unknown") {
+    throw new Error(
+      "Could not detect a React, Next, Vue or Nuxt project. Run this from your project root, or install the framework first."
+    );
+  }
+  const isVue = project.framework === "vue" || project.framework === "nuxt";
+  const componentName = options.as ?? entry.component;
+  const extension = isVue ? "vue" : project.typescript ? "tsx" : "jsx";
+  const directory = options.dir ?? project.componentsDir;
+  const path = join(project.root, directory, `${componentName}.${extension}`);
+  const contents = isVue ? renderVue(componentName, entry.component, entry.options, project) : renderReact(componentName, entry.component, entry.options, project);
+  const missingDependencies = missingFor(project);
+  if (options.dryRun) {
+    return { path, contents, written: false, missingDependencies };
+  }
+  if (existsSync(path) && !options.force) {
+    throw new Error(`${path} already exists. Pass --force to overwrite.`);
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, contents, "utf8");
+  return { path, contents, written: true, missingDependencies };
+}
+function missingFor(project) {
+  if (project.installed) return [];
+  switch (project.framework) {
+    case "nuxt":
+      return ["@ansh-ui/nuxt"];
+    case "vue":
+      return ["@ansh-ui/vue", "@ansh-ui/tokens"];
+    default:
+      return ["@ansh-ui/react", "@ansh-ui/tokens"];
+  }
+}
+function literal(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(literal).join(", ")}]`;
+  if (value === null) return "null";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+var INTERESTING_OPTIONS = /* @__PURE__ */ new Set([
+  "colors",
+  "speed",
+  "intensity",
+  "opacity",
+  "blur",
+  "seed",
+  "strength",
+  "radius",
+  "max",
+  "distance",
+  "amount",
+  "count"
+]);
+function pickDefaults(options) {
+  return options.filter((option) => INTERESTING_OPTIONS.has(option.name));
+}
+function renderReact(componentName, sourceComponent, options, project) {
+  const ts = project.typescript;
+  const defaults = pickDefaults(options);
+  const defaultLines = defaults.map((option) => `  ${option.name}: ${literal(option.default)},`).join("\n");
+  const propsType = ts ? `
+type ${componentName}Props = ComponentProps<typeof ${sourceComponent}>
+` : "";
+  const signature = ts ? `export function ${componentName}({ children, ...props }: ${componentName}Props) {` : `export function ${componentName}({ children, ...props }) {`;
+  const typeImport = ts ? `import type { ComponentProps } from 'react'
+` : "";
+  return `${typeImport}import { ${sourceComponent} } from '@ansh-ui/react'
+
+/**
+ * ${componentName} \u2014 a project-local wrapper around Ansh's ${sourceComponent}.
+ *
+ * Edit the defaults below to match your design system. Every option remains overridable per
+ * instance, because props spread after the defaults.
+ *
+ * Generated by \`ansh add\`. Safe to edit \u2014 it will not be regenerated unless you ask.
+ */
+const defaults = {
+${defaultLines}
+}
+
+${propsType}
+${signature}
+  return (
+    <${sourceComponent} {...defaults} {...props}>
+      {children}
+    </${sourceComponent}>
+  )
+}
+`;
+}
+function renderVue(componentName, sourceComponent, options, project) {
+  const defaults = pickDefaults(options);
+  const defaultLines = defaults.map((option) => `  ${option.name}: ${literal(option.default)},`).join("\n");
+  const lang = project.typescript ? ' lang="ts"' : "";
+  const importLine = project.framework === "nuxt" ? `// ${sourceComponent} is auto-imported by @ansh-ui/nuxt.` : `import { ${sourceComponent} } from '@ansh-ui/vue'`;
+  return `<script setup${lang}>
+${importLine}
+
+/**
+ * ${componentName} \u2014 a project-local wrapper around Ansh's ${sourceComponent}.
+ *
+ * Edit the defaults below to match your design system. Every option remains overridable per
+ * instance, because \`$attrs\` is bound after the defaults.
+ *
+ * Generated by \`ansh add\`. Safe to edit \u2014 it will not be regenerated unless you ask.
+ */
+const defaults = {
+${defaultLines}
+}
+</script>
+
+<template>
+  <${sourceComponent} v-bind="{ ...defaults, ...$attrs }">
+    <slot />
+  </${sourceComponent}>
+</template>
+`;
+}
+function generatePaletteReport(options = {}) {
+  const parsed = options.colors && options.colors.length > 0 ? options.colors.map((color) => parseColor(color)) : generatePalette({
+    count: options.count ?? 5,
+    seed: options.seed ?? 1,
+    lightness: options.lightness ?? 0.65,
+    saturation: options.saturation ?? 0.85,
+    spread: options.spread ?? 120
+  });
+  const colors = parsed.map((color) => {
+    const lch = rgbToOklch(color);
+    return {
+      hex: toHex(color),
+      oklch: toOklchString(color),
+      lightness: Number(lch.l.toFixed(4)),
+      chroma: Number(lch.c.toFixed(4)),
+      hue: Number(lch.h.toFixed(2))
+    };
+  });
+  const gradientSamples = options.gradient === false || parsed.length < 2 ? [] : createGradient(parsed, { space: "oklch" }).sample(9).map((color) => toHex(color));
+  const snippet = `colors={[${colors.map((c) => `'${c.hex}'`).join(", ")}]}`;
+  return { colors, gradientSamples, snippet };
+}
+var TAILWIND_KEYS = ["50", "100", "200", "300", "400", "500", "600", "700", "800", "900", "950"];
+function generateTheme(options) {
+  const base = parseColor(options.color);
+  const baseLightness = rgbToOklch(base).l;
+  const scale = createScale(base, {
+    steps: 11,
+    hueShift: options.hueShift ?? 0,
+    chromaFalloff: options.chromaFalloff ?? 0.35
+  });
+  const unsafeOnLight = [];
+  const unsafeOnDark = [];
+  const lines = [];
+  let nearestStep = "500";
+  let nearestDistance = Infinity;
+  scale.colors.forEach((color, index) => {
+    const key = TAILWIND_KEYS[index];
+    const onLight = checkContrast(color, "#ffffff");
+    const onDark = checkContrast(color, "#0b0b0f");
+    if (!onLight.passes) unsafeOnLight.push(key);
+    if (!onDark.passes) unsafeOnDark.push(key);
+    const distance = Math.abs(rgbToOklch(color).l - baseLightness);
+    if (distance < nearestDistance) {
+      nearestDistance = distance;
+      nearestStep = key;
+    }
+    lines.push(
+      `  --ansh-brand-${key}: ${toOklchString(color)}; /* ${toHex(color)}  on-white ${onLight.ratio.toFixed(2)}:1  on-black ${onDark.ratio.toFixed(2)}:1 */`
+    );
+  });
+  let accentLines = "";
+  if (options.withAccent) {
+    const [, accent] = harmony(base, "splitComplementary");
+    const accentScale = createScale(accent, { steps: 11 });
+    accentLines = "\n  /* Accent \u2014 split-complementary partner to the brand hue. */\n" + accentScale.colors.map((color, index) => `  --ansh-accent-${TAILWIND_KEYS[index]}: ${toOklchString(color)};`).join("\n") + "\n";
+  }
+  const css = `/**
+ * Ansh theme override.
+ *
+ * Generated by \`ansh theme ${options.color}\`.
+ * Import this *after* \`@ansh-ui/tokens/ansh.css\` so it wins in the cascade.
+ *
+ * Contrast ratios are annotated per step. Steps marked unsafe cannot legally hold body text on the
+ * corresponding surface \u2014 use them for fills, borders and large display type instead.
+ */
+
+:root {
+${lines.join("\n")}
+${accentLines}
+  /* Wire the semantic accent tokens to the generated scale. */
+  --ansh-accent-subtle: var(--ansh-brand-50);
+  --ansh-accent-muted: var(--ansh-brand-100);
+  --ansh-accent-default: var(--ansh-brand-600);
+  --ansh-accent-hover: var(--ansh-brand-700);
+  --ansh-accent-active: var(--ansh-brand-800);
+  --ansh-accent-text: var(--ansh-brand-700);
+  --ansh-border-focus: var(--ansh-brand-600);
+}
+
+/**
+ * Dark theme.
+ *
+ * Not an inversion. Accents step *lighter* rather than mirroring their light-mode index, because
+ * saturated colour reads as less vivid against a dark background (Helmholtz\u2013Kohlrausch).
+ */
+[data-theme='dark'] {
+  --ansh-accent-subtle: color-mix(in oklab, var(--ansh-brand-950) 40%, transparent);
+  --ansh-accent-muted: var(--ansh-brand-950);
+  --ansh-accent-default: var(--ansh-brand-500);
+  --ansh-accent-hover: var(--ansh-brand-400);
+  --ansh-accent-active: var(--ansh-brand-300);
+  --ansh-accent-text: var(--ansh-brand-300);
+  --ansh-border-focus: var(--ansh-brand-400);
+}
+
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme]) {
+    --ansh-accent-subtle: color-mix(in oklab, var(--ansh-brand-950) 40%, transparent);
+    --ansh-accent-muted: var(--ansh-brand-950);
+    --ansh-accent-default: var(--ansh-brand-500);
+    --ansh-accent-hover: var(--ansh-brand-400);
+    --ansh-accent-active: var(--ansh-brand-300);
+    --ansh-accent-text: var(--ansh-brand-300);
+    --ansh-border-focus: var(--ansh-brand-400);
+  }
+}
+`;
+  if (options.out) {
+    mkdirSync(dirname(options.out), { recursive: true });
+    writeFileSync(options.out, css, "utf8");
+  }
+  return { css, unsafeOnLight, unsafeOnDark, nearestStep };
+}
+
+// src/cli.ts
+var useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+var paint = (code, text) => useColor ? `\x1B[${code}m${text}\x1B[0m` : text;
+var bold = (text) => paint("1", text);
+var dim = (text) => paint("2", text);
+var cyan = (text) => paint("36", text);
+var green = (text) => paint("32", text);
+var yellow = (text) => paint("33", text);
+var red = (text) => paint("31", text);
+var VERSION = "0.1.0";
+function help() {
+  console.log(`
+${bold("ansh")} ${dim(`v${VERSION}`)}  \u2014  Motion, refined.
+
+${bold("USAGE")}
+  ansh <command> [options]
+
+${bold("COMMANDS")}
+  ${cyan("list")} [--effects|--behaviours]     List the component catalogue
+  ${cyan("info")} <name>                       Show a component's full option surface
+  ${cyan("add")} <name> [--as <Name>]          Generate a local wrapper component
+  ${cyan("theme")} <color> [--out <file>]      Generate a token override stylesheet
+  ${cyan("palette")} [colors...]               Generate or inspect a palette
+  ${cyan("doctor")}                            Report the detected project setup
+
+${bold("EXAMPLES")}
+  ${dim("# See what is available")}
+  ansh list
+
+  ${dim("# Generate a HeroBackground wrapper around the aurora effect")}
+  ansh add aurora --as HeroBackground
+
+  ${dim("# Build a theme from a brand colour, with contrast annotations")}
+  ansh theme '#0275f4' --out src/styles/theme.css --with-accent
+
+  ${dim("# Inspect how a palette interpolates")}
+  ansh palette '#0275f4' '#9f0550'
+
+  ${dim("# Reproducible generated palette")}
+  ansh palette --count 5 --seed hero-section
+`);
+}
+function fail(message, hint) {
+  console.error(`${red("error")}  ${message}`);
+  if (hint) console.error(`${dim("hint")}   ${hint}`);
+  process.exit(1);
+}
+function commandList(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      effects: { type: "boolean", default: false },
+      behaviours: { type: "boolean", default: false },
+      json: { type: "boolean", default: false }
+    },
+    allowPositionals: true
+  });
+  const filter = values.effects ? "effect" : values.behaviours ? "behaviour" : void 0;
+  const entries = listCatalogue(filter);
+  if (values.json) {
+    console.log(JSON.stringify(entries, null, 2));
+    return;
+  }
+  const effects2 = entries.filter((entry) => entry.kind === "effect");
+  const behaviours2 = entries.filter((entry) => entry.kind === "behaviour");
+  const print = (title, list) => {
+    if (list.length === 0) return;
+    console.log(`
+${bold(title)}`);
+    for (const entry of list) {
+      console.log(
+        `  ${cyan(entry.name.padEnd(20))} ${entry.component.padEnd(20)} ` + dim(`${entry.options.length} options`)
+      );
+    }
+  };
+  print(`Effects  ${dim("(canvas)")}`, effects2);
+  print(`Behaviours  ${dim("(DOM)")}`, behaviours2);
+  console.log(`
+${dim(`${entries.length} total. Run \`ansh info <name>\` for details.`)}
+`);
+}
+function commandInfo(argv) {
+  const name = argv[0];
+  if (!name) fail("Missing component name.", "ansh info aurora");
+  const entry = findEntry(name);
+  if (!entry) fail(`Unknown component "${name}".`, "Run `ansh list` to see what is available.");
+  console.log(`
+${bold(entry.component)}  ${dim(`(${entry.kind} "${entry.name}")`)}
+`);
+  console.log(bold("  OPTIONS"));
+  const width = Math.max(...entry.options.map((option) => option.name.length));
+  for (const option of entry.options) {
+    const value = typeof option.default === "string" ? `'${option.default}'` : Array.isArray(option.default) ? `[${option.default.map((v) => typeof v === "string" ? `'${v}'` : String(v)).join(", ")}]` : String(option.default);
+    console.log(`    ${option.name.padEnd(width)}  ${dim("=")} ${green(value)}`);
+  }
+  console.log(
+    `
+${dim(`  Docs: https://ansh.dev/docs/components/${entry.name}`)}
+${dim(`  Add:  ansh add ${entry.name}`)}
+`
+  );
+}
+function commandAdd(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: {
+      as: { type: "string" },
+      dir: { type: "string" },
+      force: { type: "boolean", default: false },
+      "dry-run": { type: "boolean", default: false }
+    },
+    allowPositionals: true
+  });
+  const name = positionals[0];
+  if (!name) fail("Missing component name.", "ansh add aurora --as HeroBackground");
+  try {
+    const result = addComponent({
+      name,
+      as: values.as,
+      dir: values.dir,
+      force: values.force,
+      dryRun: values["dry-run"]
+    });
+    if (!result.written) {
+      console.log(`${dim(`--- ${result.path} ---`)}
+`);
+      console.log(result.contents);
+      return;
+    }
+    console.log(`${green("created")}  ${result.path}`);
+    if (result.missingDependencies.length > 0) {
+      const project = detectProject();
+      console.log(
+        `
+${yellow("next")}     Install the runtime packages:
+         ${installCommand(project, result.missingDependencies)}`
+      );
+    }
+  } catch (error) {
+    fail(error instanceof Error ? error.message : String(error));
+  }
+}
+function commandTheme(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: {
+      out: { type: "string" },
+      "hue-shift": { type: "string" },
+      "chroma-falloff": { type: "string" },
+      "with-accent": { type: "boolean", default: false }
+    },
+    allowPositionals: true
+  });
+  const color = positionals[0];
+  if (!color) fail("Missing brand colour.", "ansh theme '#0275f4' --out theme.css");
+  try {
+    const report = generateTheme({
+      color,
+      out: values.out,
+      hueShift: values["hue-shift"] ? Number(values["hue-shift"]) : void 0,
+      chromaFalloff: values["chroma-falloff"] ? Number(values["chroma-falloff"]) : void 0,
+      withAccent: values["with-accent"]
+    });
+    if (!values.out) {
+      console.log(report.css);
+      return;
+    }
+    console.log(`${green("created")}  ${values.out}`);
+    console.log(`${dim("nearest")}  your input is closest to step ${report.nearestStep}`);
+    if (report.unsafeOnLight.length > 0) {
+      console.log(
+        `${yellow("warn")}     steps ${report.unsafeOnLight.join(", ")} are below 4.5:1 on white \u2014 use them for fills and borders, not body text`
+      );
+    }
+    if (report.unsafeOnDark.length > 0) {
+      console.log(
+        `${yellow("warn")}     steps ${report.unsafeOnDark.join(", ")} are below 4.5:1 on near-black`
+      );
+    }
+  } catch (error) {
+    fail(error instanceof Error ? error.message : String(error));
+  }
+}
+function commandPalette(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: {
+      count: { type: "string" },
+      seed: { type: "string" },
+      lightness: { type: "string" },
+      saturation: { type: "string" },
+      spread: { type: "string" },
+      json: { type: "boolean", default: false }
+    },
+    allowPositionals: true
+  });
+  try {
+    const report = generatePaletteReport({
+      colors: positionals.length > 0 ? positionals : void 0,
+      count: values.count ? Number(values.count) : void 0,
+      seed: values.seed,
+      lightness: values.lightness ? Number(values.lightness) : void 0,
+      saturation: values.saturation ? Number(values.saturation) : void 0,
+      spread: values.spread ? Number(values.spread) : void 0
+    });
+    if (values.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    console.log(`
+${bold("PALETTE")}
+`);
+    for (const color of report.colors) {
+      console.log(
+        `  ${swatch(color.hex)} ${color.hex.padEnd(9)} ${dim(color.oklch.padEnd(28))} ` + dim(
+          `L ${color.lightness.toFixed(3)}  C ${color.chroma.toFixed(3)}  H ${color.hue.toFixed(1)}`
+        )
+      );
+    }
+    if (report.gradientSamples.length > 0) {
+      console.log(`
+${bold("GRADIENT")} ${dim("(OKLCH interpolation)")}
+`);
+      console.log("  " + report.gradientSamples.map((hex) => swatch(hex)).join(""));
+      console.log("  " + dim(report.gradientSamples.join(" ")));
+    }
+    console.log(`
+${bold("SNIPPET")}
+
+  ${green(report.snippet)}
+`);
+  } catch (error) {
+    fail(error instanceof Error ? error.message : String(error));
+  }
+}
+function commandDoctor() {
+  const project = detectProject();
+  console.log(`
+${bold("PROJECT")}
+`);
+  console.log(`  root            ${project.root}`);
+  console.log(
+    `  framework       ${project.framework === "unknown" ? yellow("not detected") : green(project.framework)}`
+  );
+  console.log(`  typescript      ${project.typescript ? green("yes") : dim("no")}`);
+  console.log(`  package manager ${project.packageManager}`);
+  console.log(`  components dir  ${project.componentsDir}`);
+  console.log(`  import alias    ${project.alias ?? dim("none")}`);
+  console.log(`  ansh         ${project.installed ? green("installed") : yellow("not installed")}`);
+  if (!project.installed) {
+    const packages = project.framework === "nuxt" ? ["@ansh-ui/nuxt"] : project.framework === "vue" ? ["@ansh-ui/vue", "@ansh-ui/tokens"] : ["@ansh-ui/react", "@ansh-ui/tokens"];
+    console.log(`
+${yellow("next")}  ${installCommand(project, packages)}
+`);
+  } else {
+    console.log("");
+  }
+}
+function swatch(hex) {
+  if (!useColor) return "\u25A0";
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return `\x1B[48;2;${r};${g};${b}m  \x1B[0m`;
+}
+function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  switch (command) {
+    case "list":
+    case "ls":
+      return commandList(rest);
+    case "info":
+    case "show":
+      return commandInfo(rest);
+    case "add":
+      return commandAdd(rest);
+    case "theme":
+      return commandTheme(rest);
+    case "palette":
+      return commandPalette(rest);
+    case "doctor":
+      return commandDoctor();
+    case "--version":
+    case "-v":
+      console.log(VERSION);
+      return;
+    case void 0:
+    case "help":
+    case "--help":
+    case "-h":
+      return help();
+    default:
+      fail(`Unknown command "${command}".`, "Run `ansh help` to see available commands.");
+  }
+}
+main();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map