sapient-ai 0.1.0

package/README.md

@@ -0,0 +1,48 @@
+# sapient-ai CLI
+
+Thin wrapper around `shadcn` for Sapient registry usage.
+
+## Commands
+
+- `sapient-ai init`
+- `sapient-ai init --preset <handle-or-id> --template next`
+- `sapient-ai add <component>`
+- `sapient-ai shadcn <args...>`
+
+## Behavior
+
+- `init` runs Sapient's setup flow, can offer a Design System picker when no preset is specified, then initializes the repo and adds `@sapient` registry to `components.json`.
+- `init --preset <handle-or-id>` fetches a saved design-system preset and writes Sapient artifact files into `.sapient/`, including `design-system.md`, `sapient-design-system-config.json`, `tokens.json`, and `sapient-components.json`.
+- The CLI also generates a `sapient-theme.css` file next to the app's `globals.css` file and imports it automatically so the runtime theme matches the exported Sapient preset.
+- The CLI installs a small Sapient foundation pack by default, then adds any additional registry components inferred from the preset.
+- When the preset references supported Sapient registry items, the CLI also runs `shadcn add` for those components automatically.
+- `add button` is rewritten to `add @sapient/button`.
+- Pass fully-qualified names (`@scope/name`) unchanged.
+- Internally, `init` still uses `shadcn` for project wiring, but it now supplies Sapient-owned defaults so the user does not have to answer the underlying `shadcn` prompts.
+
+## Local test
+
+```bash
+npm pack ./packages/cli
+npx --yes ./sapient-ai-0.0.1.tgz --help
+```
+
+## Registry URL
+
+Default: `https://sapient-playground-design-system.vercel.app/r/{name}.json`
+
+Override:
+
+```bash
+SAPIENT_REGISTRY_URL="https://your-domain/r/{name}.json" npx sapient-ai@latest init
+```
+
+## Preset API URL
+
+Default: `https://sapient-playground-design-system.vercel.app/api/presets`
+
+Override for local development:
+
+```bash
+SAPIENT_PRESET_BASE_URL="http://localhost:3002/api/presets" npx sapient-ai@latest init --preset ferrari --template next
+```

package/bin/sapient-ai.js

@@ -0,0 +1,623 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+const DEFAULT_REGISTRY_URL =
+  process.env.SAPIENT_REGISTRY_URL ??
+  "https://sapient-playground-design-system.vercel.app/r/{name}.json";
+const DEFAULT_PRESET_BASE_URL =
+  process.env.SAPIENT_PRESET_BASE_URL ??
+  "https://sapient-playground-design-system.vercel.app/api/presets";
+const SAPIENT_ARTIFACT_DIR = ".sapient";
+
+const [, , ...argv] = process.argv;
+const [command, ...rest] = argv;
+
+function printHelp() {
+  process.stdout.write(`sapient-ai
+
+Usage:
+  sapient-ai init [shadcn-init-args...]
+  sapient-ai init --preset <handle-or-id> [shadcn-init-args...]
+  sapient-ai add <component> [shadcn-add-args...]
+  sapient-ai shadcn [raw-shadcn-args...]
+
+Examples:
+  sapient-ai init
+  sapient-ai init --preset ferrari --template next
+  sapient-ai add button
+  sapient-ai add @sapient/button
+  sapient-ai shadcn diff
+
+Environment:
+  SAPIENT_REGISTRY_URL   Override registry URL template
+                         (default: ${DEFAULT_REGISTRY_URL})
+  SAPIENT_PRESET_BASE_URL Override preset API base URL
+                         (default: ${DEFAULT_PRESET_BASE_URL})
+`);
+}
+
+function runShadcn(args) {
+  const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
+  return spawnSync(npxCmd, ["--yes", "shadcn@latest", ...args], {
+    stdio: "inherit",
+    env: process.env,
+    cwd: process.cwd(),
+  });
+}
+
+function ensureSapientRegistry() {
+  const componentsPath = path.join(process.cwd(), "components.json");
+
+  if (!fs.existsSync(componentsPath)) {
+    return;
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(componentsPath, "utf8"));
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : "Unknown parse error";
+    process.stderr.write(
+      `Warning: could not update components.json registry (${message}).\n`
+    );
+    return;
+  }
+
+  const registries =
+    parsed.registries && typeof parsed.registries === "object"
+      ? parsed.registries
+      : {};
+
+  if (registries["@sapient"]) {
+    return;
+  }
+
+  parsed.registries = registries;
+  parsed.registries["@sapient"] = DEFAULT_REGISTRY_URL;
+
+  fs.writeFileSync(
+    componentsPath,
+    `${JSON.stringify(parsed, null, 2)}\n`,
+    "utf8"
+  );
+  process.stdout.write(
+    `Updated components.json with @sapient registry: ${DEFAULT_REGISTRY_URL}\n`
+  );
+}
+
+function parseInitArgs(args) {
+  let presetId = null;
+  const passthrough = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+
+    if (value === "--preset") {
+      presetId = args[index + 1] ?? null;
+      index += 1;
+      continue;
+    }
+
+    if (value.startsWith("--preset=")) {
+      presetId = value.slice("--preset=".length);
+      continue;
+    }
+
+    passthrough.push(value);
+  }
+
+  return { presetId, passthrough };
+}
+
+async function fetchPreset(presetId) {
+  const baseUrl = DEFAULT_PRESET_BASE_URL.replace(/\/$/, "");
+  const response = await fetch(`${baseUrl}/${encodeURIComponent(presetId)}`);
+
+  if (!response.ok) {
+    throw new Error(`Preset fetch failed with status ${response.status}`);
+  }
+
+  return response.json();
+}
+
+async function fetchPresetList() {
+  const baseUrl = DEFAULT_PRESET_BASE_URL.replace(/\/$/, "");
+  const response = await fetch(baseUrl);
+
+  if (!response.ok) {
+    throw new Error(`Preset list fetch failed with status ${response.status}`);
+  }
+
+  const payload = await response.json();
+  return Array.isArray(payload?.presets) ? payload.presets : [];
+}
+
+async function promptForPresetSelection() {
+  const presets = await fetchPresetList();
+
+  if (presets.length === 0) {
+    return null;
+  }
+
+  process.stdout.write("Available Sapient Design Systems:\n");
+  presets.forEach((preset, index) => {
+    const label = preset?.projectName || preset?.name || preset?.presetHandle || preset?.presetId;
+    const handle = preset?.presetHandle ? ` (${preset.presetHandle})` : "";
+    const brand = preset?.brandName ? ` - ${preset.brandName}` : "";
+    process.stdout.write(`  ${index + 1}. ${label}${handle}${brand}\n`);
+  });
+
+  const rl = readline.createInterface({ input, output });
+
+  try {
+    while (true) {
+      const answer = (await rl.question("Select a Design System by number (or press Enter to skip): ")).trim();
+
+      if (!answer) {
+        return null;
+      }
+
+      const selectedIndex = Number.parseInt(answer, 10);
+
+      if (!Number.isNaN(selectedIndex) && selectedIndex >= 1 && selectedIndex <= presets.length) {
+        return presets[selectedIndex - 1]?.presetHandle || presets[selectedIndex - 1]?.presetId || null;
+      }
+
+      process.stdout.write("Please enter a valid number from the list above.\n");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+function writePresetFiles(preset) {
+  if (!preset?.files || !Array.isArray(preset.files)) {
+    throw new Error("Preset payload does not include files.");
+  }
+
+  for (const file of preset.files) {
+    if (!file?.path || typeof file.path !== "string") {
+      continue;
+    }
+
+    const absolutePath = path.join(process.cwd(), file.path);
+    const directory = path.dirname(absolutePath);
+    fs.mkdirSync(directory, { recursive: true });
+    fs.writeFileSync(absolutePath, file.content ?? "", "utf8");
+    process.stdout.write(`Wrote ${file.path}\n`);
+  }
+}
+
+function readJsonFileIfExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function findExistingArtifactPath(relativePath) {
+  const nextPath = path.join(process.cwd(), SAPIENT_ARTIFACT_DIR, relativePath);
+  if (fs.existsSync(nextPath)) {
+    return nextPath;
+  }
+
+  const legacyPath = path.join(process.cwd(), relativePath);
+  if (fs.existsSync(legacyPath)) {
+    return legacyPath;
+  }
+
+  return nextPath;
+}
+
+function writeJsonFile(filePath, value) {
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function normalizeBaseColor(baseColor) {
+  if (typeof baseColor !== "string" || baseColor.length === 0) {
+    return null;
+  }
+
+  const match = baseColor.match(/^([a-z-]+)-\d+$/i);
+  return match ? match[1] : baseColor;
+}
+
+function findCssEntryFromComponents() {
+  const componentsPath = path.join(process.cwd(), "components.json");
+  const components = readJsonFileIfExists(componentsPath);
+  const configuredCss = components?.tailwind?.css;
+
+  if (typeof configuredCss === "string" && configuredCss.length > 0) {
+    return configuredCss;
+  }
+
+  const candidates = ["app/globals.css", "src/app/globals.css"];
+  return candidates.find((candidate) => fs.existsSync(path.join(process.cwd(), candidate))) ?? null;
+}
+
+function toTokenMap(tokens) {
+  return Array.isArray(tokens)
+    ? tokens.reduce((accumulator, token) => {
+        if (token?.name && typeof token.name === "string") {
+          accumulator[token.name] = token?.value ?? "";
+        }
+        return accumulator;
+      }, {})
+    : {};
+}
+
+function getTokenReference(tokenMap, name, fallback) {
+  return Object.prototype.hasOwnProperty.call(tokenMap, name) ? `var(${name})` : fallback;
+}
+
+function buildSapientThemeCss({ tokens, config }) {
+  const tokenMap = toTokenMap(tokens);
+  const baseNeutral = getTokenReference(tokenMap, "--neutral-50", "0 0% 98%");
+  const baseNeutralDark = getTokenReference(tokenMap, "--neutral-950", "0 0% 12%");
+  const surfaceMid = getTokenReference(tokenMap, "--neutral-200", "0 0% 88%");
+  const surfaceStrong = getTokenReference(tokenMap, "--neutral-700", "0 0% 35%");
+  const borderMid = getTokenReference(tokenMap, "--neutral-300", "0 0% 78%");
+  const foregroundPrimary = getTokenReference(tokenMap, "--neutral-950", "0 0% 12%");
+  const foregroundSecondary = getTokenReference(tokenMap, "--neutral-600", "0 0% 44%");
+  const foregroundTertiary = getTokenReference(tokenMap, "--neutral-400", "0 0% 64%");
+  const primary = getTokenReference(tokenMap, "--primary-500", "165 89% 53%");
+  const primaryDark = getTokenReference(tokenMap, "--primary-400", "165 88% 68%");
+  const secondary = getTokenReference(tokenMap, "--secondary-600", "248 87% 63%");
+  const secondaryDark = getTokenReference(tokenMap, "--secondary-400", "247 100% 82%");
+  const destructive = getTokenReference(tokenMap, "--red-600", "345 78% 50%");
+  const success = getTokenReference(tokenMap, "--green-600", "135 69% 36%");
+  const warning = getTokenReference(tokenMap, "--yellow-600", "27 100% 44%");
+  const radius = config?.radius ? `var(--radius-token-${config.radius})` : getTokenReference(tokenMap, "--radius-token-md", "13px");
+  const cardRadius = getTokenReference(tokenMap, "--card-radius", radius);
+  const basePadding = typeof config?.padding === "number" ? `${config.padding}px` : "16px";
+  const baseGap = typeof config?.gap === "number" ? `${config.gap}px` : "12px";
+  const fontFamily =
+    typeof config?.font === "string" && config.font.length > 0 && config.font !== "default"
+      ? `'${config.font}', ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif`
+      : `ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif`;
+
+  const tokenLines = Object.entries(tokenMap)
+    .map(([name, value]) => `  ${name}: ${String(value)};`)
+    .join("\n");
+
+  return `:root {
+${tokenLines}
+  --background: ${baseNeutral};
+  --foreground: ${foregroundPrimary};
+  --card: ${baseNeutral};
+  --card-foreground: ${foregroundPrimary};
+  --popover: 0 0% 100%;
+  --popover-foreground: ${foregroundPrimary};
+  --primary: ${primary};
+  --primary-foreground: 0 0% 0%;
+  --secondary: ${secondary};
+  --secondary-foreground: 0 0% 100%;
+  --muted: ${surfaceMid};
+  --muted-foreground: ${foregroundSecondary};
+  --accent: ${primary};
+  --accent-foreground: 0 0% 0%;
+  --destructive: ${destructive};
+  --destructive-foreground: 0 0% 100%;
+  --success: ${success};
+  --success-foreground: 0 0% 100%;
+  --warning: ${warning};
+  --warning-foreground: 0 0% 100%;
+  --border: ${borderMid};
+  --input: ${borderMid};
+  --ring: ${primary};
+  --surface-primary: ${baseNeutral};
+  --surface-secondary: 0 0% 100%;
+  --surface-tertiary: ${surfaceMid};
+  --surface-inverse: ${baseNeutralDark};
+  --surface-strong: ${surfaceStrong};
+  --border-low: ${getTokenReference(tokenMap, "--neutral-100", "0 0% 95%")};
+  --border-mid: ${borderMid};
+  --border-high: ${surfaceStrong};
+  --border-accent: ${primary};
+  --border-accent-alt: ${secondary};
+  --foreground-secondary: ${foregroundSecondary};
+  --foreground-tertiary: ${foregroundTertiary};
+  --foreground-strong: ${getTokenReference(tokenMap, "--primary-800", primary)};
+  --foreground-accent: ${getTokenReference(tokenMap, "--primary-600", primary)};
+  --foreground-accent-alt: ${secondary};
+  --sidebar: ${baseNeutral};
+  --sidebar-foreground: ${foregroundPrimary};
+  --sidebar-primary: ${primary};
+  --sidebar-primary-foreground: 0 0% 0%;
+  --sidebar-accent: ${surfaceMid};
+  --sidebar-accent-foreground: ${foregroundPrimary};
+  --sidebar-border: ${borderMid};
+  --sidebar-ring: ${primary};
+  --chart-1: ${primary};
+  --chart-2: ${getTokenReference(tokenMap, "--secondary-500", secondary)};
+  --chart-3: ${getTokenReference(tokenMap, "--neutral-700", surfaceStrong)};
+  --chart-4: ${getTokenReference(tokenMap, "--primary-300", primary)};
+  --chart-5: ${getTokenReference(tokenMap, "--neutral-500", foregroundSecondary)};
+  --radius: ${radius};
+  --card-radius: ${cardRadius};
+  --sapient-base-padding: ${basePadding};
+  --sapient-base-gap: ${baseGap};
+  --sapient-font-body: ${fontFamily};
+}
+
+.dark {
+  --background: ${baseNeutralDark};
+  --foreground: ${baseNeutral};
+  --card: ${getTokenReference(tokenMap, "--neutral-900", "0 0% 25%")};
+  --card-foreground: ${baseNeutral};
+  --popover: ${getTokenReference(tokenMap, "--neutral-900", "0 0% 25%")};
+  --popover-foreground: ${baseNeutral};
+  --primary: ${primaryDark};
+  --primary-foreground: 0 0% 0%;
+  --secondary: ${secondaryDark};
+  --secondary-foreground: 0 0% 100%;
+  --muted: ${getTokenReference(tokenMap, "--neutral-800", "0 0% 32%")};
+  --muted-foreground: ${getTokenReference(tokenMap, "--neutral-300", "0 0% 78%")};
+  --accent: ${primaryDark};
+  --accent-foreground: 0 0% 0%;
+  --border: ${getTokenReference(tokenMap, "--neutral-800", "0 0% 32%")};
+  --input: ${getTokenReference(tokenMap, "--neutral-800", "0 0% 32%")};
+  --ring: ${primaryDark};
+  --surface-primary: ${baseNeutralDark};
+  --surface-secondary: ${getTokenReference(tokenMap, "--neutral-900", "0 0% 25%")};
+  --surface-tertiary: ${getTokenReference(tokenMap, "--neutral-800", "0 0% 32%")};
+  --surface-inverse: ${baseNeutral};
+  --surface-strong: ${getTokenReference(tokenMap, "--neutral-200", "0 0% 88%")};
+  --border-accent: ${primaryDark};
+  --border-accent-alt: ${secondaryDark};
+  --foreground-secondary: ${getTokenReference(tokenMap, "--neutral-300", "0 0% 78%")};
+  --foreground-tertiary: ${getTokenReference(tokenMap, "--neutral-400", "0 0% 64%")};
+  --foreground-strong: ${getTokenReference(tokenMap, "--primary-200", primaryDark)};
+  --foreground-accent: ${primaryDark};
+  --foreground-accent-alt: ${secondaryDark};
+  --sidebar: ${getTokenReference(tokenMap, "--neutral-900", "0 0% 25%")};
+  --sidebar-foreground: ${baseNeutral};
+  --sidebar-primary: ${primaryDark};
+  --sidebar-primary-foreground: 0 0% 0%;
+  --sidebar-accent: ${getTokenReference(tokenMap, "--neutral-800", "0 0% 32%")};
+  --sidebar-accent-foreground: ${baseNeutral};
+  --sidebar-border: ${getTokenReference(tokenMap, "--neutral-800", "0 0% 32%")};
+  --sidebar-ring: ${primaryDark};
+  --chart-1: ${primaryDark};
+  --chart-2: ${secondaryDark};
+}
+
+html {
+  font-family: var(--sapient-font-body);
+}
+`;
+}
+
+function ensureCssImport(cssPath, importPath) {
+  const absoluteCssPath = path.join(process.cwd(), cssPath);
+
+  if (!fs.existsSync(absoluteCssPath)) {
+    return;
+  }
+
+  const currentContent = fs.readFileSync(absoluteCssPath, "utf8");
+
+  if (currentContent.includes(importPath)) {
+    return;
+  }
+
+  const lines = currentContent.split("\n");
+  let insertIndex = 0;
+
+  while (insertIndex < lines.length && lines[insertIndex].trim().startsWith("@import")) {
+    insertIndex += 1;
+  }
+
+  lines.splice(insertIndex, 0, `@import "${importPath}";`);
+  fs.writeFileSync(absoluteCssPath, lines.join("\n"), "utf8");
+}
+
+function applySapientPresetTheme() {
+  const configPath = findExistingArtifactPath("sapient-design-system-config.json");
+  const tokensPath = findExistingArtifactPath("tokens.json");
+  const componentsPath = path.join(process.cwd(), "components.json");
+  const config = readJsonFileIfExists(configPath);
+  const tokens = readJsonFileIfExists(tokensPath);
+  const components = readJsonFileIfExists(componentsPath);
+  const cssPath = findCssEntryFromComponents();
+
+  if (!config || !tokens) {
+    return;
+  }
+
+  if (components && typeof components === "object") {
+    const normalizedBaseColor = normalizeBaseColor(config.baseColor);
+    if (normalizedBaseColor) {
+      components.tailwind = components.tailwind && typeof components.tailwind === "object" ? components.tailwind : {};
+      components.tailwind.baseColor = normalizedBaseColor;
+    }
+
+    components.sapient =
+      components.sapient && typeof components.sapient === "object"
+        ? components.sapient
+        : {};
+    components.sapient.artifactsDir = SAPIENT_ARTIFACT_DIR;
+    components.sapient.configPath = `${SAPIENT_ARTIFACT_DIR}/sapient-design-system-config.json`;
+    components.sapient.tokensPath = `${SAPIENT_ARTIFACT_DIR}/tokens.json`;
+    components.sapient.themeCssPath = cssPath
+      ? path.join(path.dirname(cssPath), "sapient-theme.css")
+      : "app/sapient-theme.css";
+    components.sapient.baseColorToken =
+      typeof config.baseColor === "string" ? config.baseColor : null;
+    components.sapient.iconLibrary =
+      typeof config.iconLibrary === "string" ? config.iconLibrary : null;
+    components.sapient.font =
+      typeof config.font === "string" ? config.font : null;
+    components.sapient.radius =
+      typeof config.radius === "string" ? config.radius : null;
+    components.sapient.spacing =
+      typeof config.padding === "number" || typeof config.gap === "number"
+        ? {
+            padding: typeof config.padding === "number" ? config.padding : null,
+            gap: typeof config.gap === "number" ? config.gap : null,
+          }
+        : null;
+
+    writeJsonFile(componentsPath, components);
+  }
+
+  if (!cssPath) {
+    return;
+  }
+
+  const themeFilePath = path.join(path.dirname(cssPath), "sapient-theme.css");
+  const absoluteThemePath = path.join(process.cwd(), themeFilePath);
+  const themeCss = buildSapientThemeCss({ tokens, config });
+
+  fs.mkdirSync(path.dirname(absoluteThemePath), { recursive: true });
+  fs.writeFileSync(absoluteThemePath, themeCss, "utf8");
+  ensureCssImport(cssPath, "./sapient-theme.css");
+  process.stdout.write(`Applied Sapient theme to ${cssPath}\n`);
+}
+
+function installRegistryComponents(preset) {
+  if (!Array.isArray(preset?.registryComponents) || preset.registryComponents.length === 0) {
+    return;
+  }
+
+  const result = runShadcn(["add", ...preset.registryComponents]);
+
+  if (result.error) {
+    throw new Error(`Failed to install registry components: ${result.error.message}`);
+  }
+
+  if ((result.status ?? 1) !== 0) {
+    throw new Error("Registry component installation failed.");
+  }
+}
+
+function hasOption(args, optionName) {
+  return args.some((value) => value === optionName || value.startsWith(`${optionName}=`));
+}
+
+function buildHiddenShadcnInitArgs(passthrough) {
+  const args = ["init"];
+
+  if (!hasOption(passthrough, "--yes")) {
+    args.push("--yes");
+  }
+
+  if (!hasOption(passthrough, "--base")) {
+    args.push("--base", "radix");
+  }
+
+  if (!hasOption(passthrough, "--preset")) {
+    args.push("--preset", "nova");
+  }
+
+  return [...args, ...passthrough];
+}
+
+async function handleInit(args) {
+  const { presetId, passthrough } = parseInitArgs(args);
+  let selectedPreset = presetId;
+
+  if (!selectedPreset) {
+    try {
+      selectedPreset = await promptForPresetSelection();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      process.stderr.write(`Warning: could not load Sapient Design Systems (${message}). Continuing without a preset.\n`);
+    }
+  }
+
+  const result = runShadcn(buildHiddenShadcnInitArgs(passthrough));
+
+  if (result.error) {
+    process.stderr.write(`Failed to run shadcn init: ${result.error.message}\n`);
+    process.exit(1);
+  }
+
+  if ((result.status ?? 1) !== 0) {
+    process.exit(result.status ?? 1);
+  }
+
+  ensureSapientRegistry();
+
+  if (!selectedPreset) {
+    process.exit(0);
+  }
+
+  try {
+    const preset = await fetchPreset(selectedPreset);
+    writePresetFiles(preset);
+    applySapientPresetTheme();
+    installRegistryComponents(preset);
+    process.stdout.write(`Applied preset ${preset.presetHandle || selectedPreset}\n`);
+    process.exit(0);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    process.stderr.write(`Failed to apply preset ${selectedPreset}: ${message}\n`);
+    process.exit(1);
+  }
+}
+
+function handleAdd(args) {
+  if (args.length === 0) {
+    process.stderr.write("Missing component name. Example: sapient-ai add button\n");
+    process.exit(1);
+  }
+
+  const [rawComponent, ...remaining] = args;
+  const resolvedComponent =
+    rawComponent.startsWith("@") ||
+    rawComponent.includes("://") ||
+    rawComponent.includes("/")
+      ? rawComponent
+      : `@sapient/${rawComponent}`;
+
+  const result = runShadcn(["add", resolvedComponent, ...remaining]);
+
+  if (result.error) {
+    process.stderr.write(`Failed to run shadcn add: ${result.error.message}\n`);
+    process.exit(1);
+  }
+
+  process.exit(result.status ?? 1);
+}
+
+function handleRawShadcn(args) {
+  const result = runShadcn(args);
+
+  if (result.error) {
+    process.stderr.write(`Failed to run shadcn: ${result.error.message}\n`);
+    process.exit(1);
+  }
+
+  process.exit(result.status ?? 1);
+}
+
+if (!command || command === "-h" || command === "--help" || command === "help") {
+  printHelp();
+  process.exit(0);
+}
+
+if (command === "init") {
+  await handleInit(rest);
+}
+
+if (command === "add") {
+  handleAdd(rest);
+}
+
+if (command === "shadcn") {
+  handleRawShadcn(rest);
+}
+
+handleRawShadcn(argv);