foldcn 0.0.1

package/dist/bin.js

@@ -0,0 +1,1126 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/bin.ts
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Effect as Effect12 } from "effect";
+
+// src/cli.ts
+import { Effect as Effect11 } from "effect";
+import { Command as Command4 } from "effect/unstable/cli";
+
+// src/command/add/add.ts
+import { Console, Effect as Effect8, FileSystem as FileSystem6, Option as Option3, Path as Path4 } from "effect";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+// ../registry/dist/registry/index.js
+var exports_registry = {};
+__export(exports_registry, {
+  Manifest: () => Manifest,
+  ItemType: () => ItemType,
+  ItemFile: () => ItemFile,
+  Item: () => Item,
+  CssVars: () => CssVars,
+  Css: () => Css
+});
+
+// ../registry/dist/registry/registry.js
+import { Schema } from "effect";
+var ItemType = Schema.Literals([
+  "registry:ui",
+  "registry:lib",
+  "registry:block",
+  "registry:theme",
+  "registry:file",
+  "registry:example"
+]).annotate({ identifier: "Foldcn.Registry.ItemType" });
+var ItemFile = Schema.Struct({
+  path: Schema.String,
+  type: ItemType,
+  target: Schema.optionalKey(Schema.String),
+  content: Schema.optionalKey(Schema.String)
+}).annotate({ identifier: "Foldcn.Registry.ItemFile" });
+var CssVars = Schema.Struct({
+  theme: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+  light: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+  dark: Schema.optionalKey(Schema.Record(Schema.String, Schema.String))
+}).annotate({ identifier: "Foldcn.Registry.CssVars" });
+var Css = Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.suspend(() => Css)])).annotate({ identifier: "Foldcn.Registry.Css" });
+var Item = Schema.Struct({
+  $schema: Schema.optionalKey(Schema.String),
+  name: Schema.String,
+  type: ItemType,
+  title: Schema.optionalKey(Schema.String),
+  description: Schema.optionalKey(Schema.String),
+  dependencies: Schema.optionalKey(Schema.Array(Schema.String)),
+  devDependencies: Schema.optionalKey(Schema.Array(Schema.String)),
+  registryDependencies: Schema.optionalKey(Schema.Array(Schema.String)),
+  files: Schema.optionalKey(Schema.Array(ItemFile)),
+  cssVars: Schema.optionalKey(CssVars),
+  css: Schema.optionalKey(Css),
+  docs: Schema.optionalKey(Schema.String),
+  categories: Schema.optionalKey(Schema.Array(Schema.String))
+}).annotate({ identifier: "Foldcn.Registry.Item" });
+var Manifest = Schema.Struct({
+  $schema: Schema.optionalKey(Schema.String),
+  name: Schema.String,
+  homepage: Schema.String,
+  items: Schema.Array(Item)
+}).annotate({ identifier: "Foldcn.Registry.Manifest" });
+// ../registry/dist/componentsConfig/index.js
+var exports_componentsConfig = {};
+__export(exports_componentsConfig, {
+  defaultCss: () => defaultCss,
+  defaultBaseColor: () => defaultBaseColor,
+  defaultAliases: () => defaultAliases,
+  Config: () => Config,
+  Aliases: () => Aliases
+});
+
+// ../registry/dist/componentsConfig/componentsConfig.js
+import { Schema as Schema2 } from "effect";
+var Aliases = Schema2.Struct({
+  ui: Schema2.String,
+  lib: Schema2.String
+}).annotate({ identifier: "Foldcn.ComponentsConfig.Aliases" });
+var Config = Schema2.Struct({
+  $schema: Schema2.optionalKey(Schema2.String),
+  css: Schema2.String,
+  baseColor: Schema2.String,
+  aliases: Aliases,
+  registries: Schema2.optionalKey(Schema2.Record(Schema2.String, Schema2.String))
+}).annotate({ identifier: "Foldcn.ComponentsConfig.Config" });
+var defaultCss = "src/styles.css";
+var defaultBaseColor = "neutral";
+var defaultAliases = {
+  ui: "src/components/ui",
+  lib: "src/lib"
+};
+// ../registry/dist/resolveTree/index.js
+var exports_resolveTree = {};
+__export(exports_resolveTree, {
+  resolve: () => resolve,
+  mergeItems: () => mergeItems
+});
+
+// ../registry/dist/resolveTree/resolveTree.js
+import { Effect, Option } from "effect";
+var fetchConcurrency = 8;
+var resolve = (rootSpecs, getItem) => Effect.gen(function* () {
+  const seenKeys = new Set;
+  const seenRequests = new Set;
+  const ordered = [];
+  let frontier = rootSpecs.map((spec) => [spec, Option.none()]);
+  while (frontier.length > 0) {
+    const requests = frontier.filter(([spec, maybeOrigin]) => {
+      const requestKey = `${Option.getOrElse(maybeOrigin, () => "")}::${spec}`;
+      if (seenRequests.has(requestKey)) {
+        return false;
+      }
+      seenRequests.add(requestKey);
+      return true;
+    });
+    const fetched = yield* Effect.forEach(requests, ([spec, maybeOrigin]) => getItem(spec, maybeOrigin), {
+      concurrency: fetchConcurrency
+    });
+    const next = [];
+    for (const { key, item } of fetched) {
+      if (seenKeys.has(key)) {
+        continue;
+      }
+      seenKeys.add(key);
+      ordered.push(item);
+      for (const dependency of item.registryDependencies ?? []) {
+        next.push([dependency, Option.some(key)]);
+      }
+    }
+    frontier = next;
+  }
+  return mergeItems(ordered);
+});
+var mergeItems = (items) => {
+  const warnings = [];
+  const dependencies = mergeDependencyLists(items.map((item) => item.dependencies ?? []), warnings);
+  const devDependencies = mergeDependencyLists(items.map((item) => item.devDependencies ?? []), warnings);
+  const files = [];
+  const seenFiles = new Map;
+  for (const item of items) {
+    for (const file of item.files ?? []) {
+      const fileKey = file.target ?? file.path;
+      const existing = seenFiles.get(fileKey);
+      if (existing === undefined) {
+        seenFiles.set(fileKey, file);
+        files.push(file);
+        continue;
+      }
+      if (existing.content !== file.content) {
+        warnings.push(`Skipped duplicate file "${fileKey}" from item "${item.name}" with divergent content`);
+      }
+    }
+  }
+  let cssVars = {};
+  let css = {};
+  for (const item of items) {
+    if (item.cssVars !== undefined) {
+      cssVars = mergeCssVars(cssVars, item.cssVars, item.name, warnings);
+    }
+    if (item.css !== undefined) {
+      css = mergeCss(css, item.css, item.name, warnings);
+    }
+  }
+  return { items, dependencies, devDependencies, files, cssVars, css, warnings };
+};
+var packageName = (spec) => {
+  const versionSeparator = spec.lastIndexOf("@");
+  if (versionSeparator > 0) {
+    return spec.slice(0, versionSeparator);
+  }
+  return spec;
+};
+var mergeDependencyLists = (lists, warnings) => {
+  const byName = new Map;
+  for (const list of lists) {
+    for (const spec of list) {
+      const name = packageName(spec);
+      const existing = byName.get(name);
+      if (existing === undefined) {
+        byName.set(name, spec);
+        continue;
+      }
+      if (existing !== spec) {
+        warnings.push(`Kept dependency "${existing}" over conflicting "${spec}"`);
+      }
+    }
+  }
+  return Array.from(byName.values());
+};
+var mergeVarRecord = (existing, incoming, scope, itemName, warnings) => {
+  if (incoming === undefined) {
+    return existing;
+  }
+  if (existing === undefined) {
+    return incoming;
+  }
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(incoming)) {
+    const current = merged[key];
+    if (current === undefined) {
+      merged[key] = value;
+      continue;
+    }
+    if (current !== value) {
+      warnings.push(`Kept ${scope} variable "${key}: ${current}" over "${value}" from item "${itemName}"`);
+    }
+  }
+  return merged;
+};
+var mergeCssVars = (existing, incoming, itemName, warnings) => {
+  const theme = mergeVarRecord(existing.theme, incoming.theme, "theme", itemName, warnings);
+  const light = mergeVarRecord(existing.light, incoming.light, "light", itemName, warnings);
+  const dark = mergeVarRecord(existing.dark, incoming.dark, "dark", itemName, warnings);
+  return {
+    ...theme === undefined ? {} : { theme },
+    ...light === undefined ? {} : { light },
+    ...dark === undefined ? {} : { dark }
+  };
+};
+var mergeCss = (existing, incoming, itemName, warnings) => {
+  const merged = { ...existing };
+  for (const [selector, value] of Object.entries(incoming)) {
+    const current = merged[selector];
+    if (current === undefined) {
+      merged[selector] = value;
+      continue;
+    }
+    if (typeof current === "object" && typeof value === "object") {
+      merged[selector] = mergeCss(current, value, itemName, warnings);
+      continue;
+    }
+    if (current !== value) {
+      warnings.push(`Kept css "${selector}" over conflicting definition from item "${itemName}"`);
+    }
+  }
+  return merged;
+};
+// ../registry/dist/cssMerge/index.js
+var exports_cssMerge = {};
+__export(exports_cssMerge, {
+  merge: () => merge,
+  CssParseError: () => CssParseError
+});
+
+// ../registry/dist/cssMerge/cssMerge.js
+import { Effect as Effect2, Schema as Schema3 } from "effect";
+import postcss from "postcss";
+
+class CssParseError extends Schema3.TaggedErrorClass()("CssParseError", {
+  message: Schema3.String
+}) {
+}
+var darkVariantParams = "(&:is(.dark *))";
+var radiusScale = {
+  "--radius-sm": "calc(var(--radius) - 4px)",
+  "--radius-md": "calc(var(--radius) - 2px)",
+  "--radius-lg": "var(--radius)",
+  "--radius-xl": "calc(var(--radius) + 4px)"
+};
+var merge = (options) => Effect2.try({
+  try: () => mergeSync(options),
+  catch: (error) => new CssParseError({ message: String(error) })
+});
+var mergeSync = (options) => {
+  const root = postcss.parse(options.css);
+  const isOverwriting = options.isOverwriting ?? false;
+  const hasCssVars = options.cssVars !== undefined && Object.values(options.cssVars).some((vars) => vars !== undefined && Object.keys(vars).length > 0);
+  if (hasCssVars && options.cssVars !== undefined) {
+    ensureDarkVariant(root);
+    applyCssVars(root, options.cssVars, isOverwriting);
+    applyThemeMapping(root, options.cssVars);
+  }
+  if (options.extraCss !== undefined) {
+    applyExtraCss(root, options.extraCss);
+  }
+  let output = root.toResult().css;
+  output = output.replace(/(\n\s*\n)+/g, `
+
+`);
+  return `${output.trimEnd()}
+`;
+};
+var isAtRule = (node, name) => node.type === "atrule" && node.name === name;
+var findAtRule = (root, name, params) => root.nodes.find((node) => isAtRule(node, name) && (params === undefined || node.params === params));
+var lastAtRule = (root, name) => {
+  const matches = root.nodes.filter((node) => isAtRule(node, name));
+  return matches.at(-1);
+};
+var ensureDarkVariant = (root) => {
+  const existing = root.nodes.find((node) => isAtRule(node, "custom-variant") && node.params.startsWith("dark"));
+  if (existing !== undefined) {
+    return;
+  }
+  const variantNode = postcss.atRule({
+    name: "custom-variant",
+    params: `dark ${darkVariantParams}`,
+    raws: { semicolon: true, before: `
+
+` }
+  });
+  const lastImport = lastAtRule(root, "import");
+  if (lastImport !== undefined) {
+    root.insertAfter(lastImport, variantNode);
+    return;
+  }
+  const firstNode = root.nodes.at(0);
+  if (firstNode !== undefined) {
+    root.insertAfter(firstNode, variantNode);
+    return;
+  }
+  root.append(variantNode);
+};
+var upsertThemeNode = (root) => {
+  const existing = findAtRule(root, "theme", "inline");
+  if (existing !== undefined) {
+    return existing;
+  }
+  const themeNode = postcss.atRule({
+    name: "theme",
+    params: "inline",
+    nodes: [],
+    raws: { semicolon: true, between: " ", before: `
+
+` }
+  });
+  root.append(themeNode);
+  return themeNode;
+};
+var upsertRule = (root, selector) => {
+  const existing = root.nodes.find((node) => node.type === "rule" && node.selector === selector);
+  if (existing !== undefined) {
+    return existing;
+  }
+  const ruleNode = postcss.rule({
+    selector,
+    nodes: [],
+    raws: { semicolon: true, between: " ", before: `
+
+` }
+  });
+  root.append(ruleNode);
+  return ruleNode;
+};
+var upsertDeclaration = (container, prop, value, isOverwriting) => {
+  const existing = container.nodes?.find((node) => node.type === "decl" && node.prop === prop);
+  const declaration = postcss.decl({ prop, value, raws: { semicolon: true, before: `
+  ` } });
+  if (existing !== undefined) {
+    if (isOverwriting && existing.value !== value) {
+      existing.replaceWith(declaration);
+    }
+    return;
+  }
+  container.append(declaration);
+};
+var normalizeProp = (name) => `--${name.replace(/^--/, "")}`;
+var applyCssVars = (root, cssVars, isOverwriting) => {
+  if (cssVars.theme !== undefined && Object.keys(cssVars.theme).length > 0) {
+    const themeNode = upsertThemeNode(root);
+    for (const [name, value] of Object.entries(cssVars.theme)) {
+      upsertDeclaration(themeNode, normalizeProp(name), value, isOverwriting);
+    }
+  }
+  const selectorVars = [
+    [":root", cssVars.light],
+    [".dark", cssVars.dark]
+  ];
+  for (const [selector, vars] of selectorVars) {
+    if (vars === undefined || Object.keys(vars).length === 0) {
+      continue;
+    }
+    const ruleNode = upsertRule(root, selector);
+    for (const [name, value] of Object.entries(vars)) {
+      upsertDeclaration(ruleNode, normalizeProp(name), value, isOverwriting);
+    }
+  }
+};
+var isColorValue = (value) => value.startsWith("hsl") || value.startsWith("rgb") || value.startsWith("#") || value.startsWith("oklch") || value.includes("--color-");
+var applyThemeMapping = (root, cssVars) => {
+  const scopes = [cssVars.light, cssVars.dark].filter((vars) => vars !== undefined);
+  const names = Array.from(new Set(scopes.flatMap((vars) => Object.keys(vars))));
+  if (names.length === 0) {
+    return;
+  }
+  const themeNode = upsertThemeNode(root);
+  for (const name of names) {
+    const value = scopes.map((vars) => vars[name]).find((found) => found !== undefined);
+    if (value === undefined) {
+      continue;
+    }
+    if (name === "radius") {
+      for (const [prop2, radiusValue] of Object.entries(radiusScale)) {
+        upsertDeclaration(themeNode, prop2, radiusValue, false);
+      }
+      continue;
+    }
+    const bare = name.replace(/^--/, "");
+    const prop = isColorValue(value) ? `--color-${bare}` : `--${bare}`;
+    upsertDeclaration(themeNode, prop, `var(--${bare})`, false);
+  }
+};
+var atRuleHeader = (selector) => {
+  const match = selector.match(/^@([a-zA-Z-]+)\s*(.*)$/);
+  if (match === null) {
+    return;
+  }
+  const name = match[1];
+  const params = match[2];
+  if (name === undefined) {
+    return;
+  }
+  return [name, params ?? ""];
+};
+var applyExtraCss = (root, extraCss) => {
+  for (const [selector, value] of Object.entries(extraCss)) {
+    const header = atRuleHeader(selector);
+    if (header !== undefined) {
+      applyAtRule(root, header[0], header[1], value);
+      continue;
+    }
+    if (typeof value === "object") {
+      const ruleNode = upsertRule(root, selector);
+      applyBody(ruleNode, value);
+    }
+  }
+};
+var applyAtRule = (root, name, params, value) => {
+  if (name === "import" || name === "plugin" || name === "custom-variant") {
+    const exists = root.nodes.some((node) => isAtRule(node, name) && node.params === params);
+    if (!exists) {
+      const atRuleNode2 = postcss.atRule({ name, params, raws: { semicolon: true, before: `
+` } });
+      const lastImport = lastAtRule(root, "import");
+      if (lastImport !== undefined) {
+        root.insertAfter(lastImport, atRuleNode2);
+      } else {
+        root.prepend(atRuleNode2);
+      }
+    }
+    return;
+  }
+  if (typeof value === "object" && Object.keys(value).length === 0) {
+    const exists = root.nodes.some((node) => isAtRule(node, name) && node.params === params);
+    if (!exists) {
+      root.append(postcss.atRule({ name, params, raws: { semicolon: true, before: `
+
+` } }));
+    }
+    return;
+  }
+  if (name === "keyframes") {
+    const themeNode = upsertThemeNode(root);
+    const existing2 = themeNode.nodes?.find((node) => node.type === "atrule" && isAtRule(node, "keyframes") && node.params === params);
+    const keyframesNode = postcss.atRule({
+      name,
+      params,
+      nodes: [],
+      raws: { semicolon: true, between: " ", before: `
+  ` }
+    });
+    if (existing2 !== undefined) {
+      existing2.replaceWith(keyframesNode);
+    } else {
+      themeNode.append(keyframesNode);
+    }
+    if (typeof value === "object") {
+      applyBody(keyframesNode, value);
+    }
+    return;
+  }
+  const existing = root.nodes.find((node) => isAtRule(node, name) && node.params === params);
+  const atRuleNode = existing ?? (() => {
+    const created = postcss.atRule({
+      name,
+      params,
+      nodes: [],
+      raws: { semicolon: true, between: " ", before: `
+
+` }
+    });
+    root.append(created);
+    return created;
+  })();
+  if (typeof value === "object") {
+    applyBody(atRuleNode, value);
+  }
+};
+var applyBody = (container, body) => {
+  for (const [key, value] of Object.entries(body)) {
+    if (typeof value === "string" && key.startsWith("@")) {
+      const header2 = atRuleHeader(key);
+      if (header2 !== undefined) {
+        const [name, params] = header2;
+        const exists = container.nodes?.some((node) => node.type === "atrule" && node.name === name && node.params === params);
+        if (exists !== true) {
+          container.append(postcss.atRule({ name, params, raws: { semicolon: true, before: `
+  ` } }));
+        }
+      }
+      continue;
+    }
+    if (typeof value === "string") {
+      upsertDeclaration(container, key, value, true);
+      continue;
+    }
+    const header = atRuleHeader(key);
+    if (header !== undefined) {
+      const [name, params] = header;
+      if (typeof value === "object" && Object.keys(value).length === 0) {
+        const exists = container.nodes?.some((node) => node.type === "atrule" && node.name === name && node.params === params);
+        if (exists !== true) {
+          container.append(postcss.atRule({ name, params, raws: { semicolon: true, before: `
+  ` } }));
+        }
+        continue;
+      }
+      const existing2 = container.nodes?.find((node) => node.type === "atrule" && node.name === name && node.params === params);
+      const nested2 = existing2 ?? (() => {
+        const created = postcss.atRule({
+          name,
+          params,
+          nodes: [],
+          raws: { semicolon: true, between: " ", before: `
+  ` }
+        });
+        container.append(created);
+        return created;
+      })();
+      applyBody(nested2, value);
+      continue;
+    }
+    const existing = container.nodes?.find((node) => node.type === "rule" && node.selector === key);
+    const nested = existing ?? (() => {
+      const created = postcss.rule({
+        selector: key,
+        nodes: [],
+        raws: { semicolon: true, between: " ", before: `
+  ` }
+      });
+      container.append(created);
+      return created;
+    })();
+    applyBody(nested, value);
+  }
+};
+// src/constants/constants.ts
+var defaultRegistryTemplate = "https://foldcn.dev/r/{name}.json";
+var registryUrlEnvVar = "FOLDCN_REGISTRY_URL";
+var itemSchemaUrl = "https://foldcn.dev/schema/registry-item.json";
+var componentsSchemaUrl = "https://foldcn.dev/schema/components.json";
+// src/error/error.ts
+import { Schema as Schema4 } from "effect";
+
+class JsonParseError extends Schema4.TaggedErrorClass()("JsonParseError", {
+  path: Schema4.String,
+  message: Schema4.String
+}) {
+}
+
+class UnknownRegistryDependencyError extends Schema4.TaggedErrorClass()("UnknownRegistryDependencyError", {
+  itemName: Schema4.String,
+  dependency: Schema4.String
+}) {
+}
+
+class ConfigNotFoundError extends Schema4.TaggedErrorClass()("ConfigNotFoundError", {
+  cwd: Schema4.String
+}) {
+}
+
+class RegistryFetchError extends Schema4.TaggedErrorClass()("RegistryFetchError", {
+  spec: Schema4.String,
+  message: Schema4.String
+}) {
+}
+
+class RegistryNotConfiguredError extends Schema4.TaggedErrorClass()("RegistryNotConfiguredError", {
+  namespace: Schema4.String
+}) {
+}
+
+class UnsafeTargetError extends Schema4.TaggedErrorClass()("UnsafeTargetError", {
+  target: Schema4.String
+}) {
+}
+
+class FileConflictError extends Schema4.TaggedErrorClass()("FileConflictError", {
+  paths: Schema4.Array(Schema4.String)
+}) {
+}
+
+class InstallFailedError extends Schema4.TaggedErrorClass()("InstallFailedError", {
+  packageManager: Schema4.String,
+  invocation: Schema4.String,
+  exitCode: Schema4.Number
+}) {
+}
+
+class StylesheetNotFoundError extends Schema4.TaggedErrorClass()("StylesheetNotFoundError", {
+  path: Schema4.String
+}) {
+}
+// src/installer/installer.ts
+import { Effect as Effect4, FileSystem as FileSystem2, Path } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+
+// src/json/json.ts
+import { Effect as Effect3, FileSystem } from "effect";
+var readJsonFile = (filePath) => Effect3.gen(function* () {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const text = yield* fileSystem.readFileString(filePath);
+  return yield* Effect3.try({
+    try: () => JSON.parse(text),
+    catch: (error2) => new JsonParseError({ path: filePath, message: String(error2) })
+  });
+});
+var writeJsonFile = (filePath, value) => Effect3.gen(function* () {
+  const fileSystem = yield* FileSystem.FileSystem;
+  yield* fileSystem.writeFileString(filePath, `${JSON.stringify(value, null, 2)}
+`);
+});
+// src/installer/installer.ts
+var lockfilePackageManagers = [
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["package-lock.json", "npm"]
+];
+var defaultPackageManager = "pnpm";
+var detectPackageManager = (cwd) => Effect4.gen(function* () {
+  const fileSystem = yield* FileSystem2.FileSystem;
+  const path = yield* Path.Path;
+  const packageJsonPath = path.join(cwd, "package.json");
+  const hasPackageJson = yield* fileSystem.exists(packageJsonPath);
+  if (hasPackageJson) {
+    const packageJson = yield* readJsonFile(packageJsonPath).pipe(Effect4.orElseSucceed(() => ({})));
+    const declared = packageJson.packageManager;
+    if (declared !== undefined) {
+      const separator = declared.indexOf("@");
+      return separator > 0 ? declared.slice(0, separator) : declared;
+    }
+  }
+  for (const [lockfile, packageManager] of lockfilePackageManagers) {
+    const hasLockfile = yield* fileSystem.exists(path.join(cwd, lockfile));
+    if (hasLockfile) {
+      return packageManager;
+    }
+  }
+  return defaultPackageManager;
+});
+var install = (plan) => Effect4.gen(function* () {
+  const invocations = [];
+  if (plan.dependencies.length > 0) {
+    invocations.push(["add", ...plan.dependencies]);
+  }
+  if (plan.devDependencies.length > 0) {
+    invocations.push(["add", "-D", ...plan.devDependencies]);
+  }
+  for (const invocationArgs of invocations) {
+    const exitCode = yield* Effect4.scoped(Effect4.gen(function* () {
+      const handle = yield* ChildProcess.make(plan.packageManager, invocationArgs, {
+        cwd: plan.cwd,
+        stdout: "inherit",
+        stderr: "inherit"
+      });
+      return yield* handle.exitCode;
+    }));
+    if (exitCode !== 0) {
+      return yield* new InstallFailedError({
+        packageManager: plan.packageManager,
+        invocation: invocationArgs.join(" "),
+        exitCode
+      });
+    }
+  }
+});
+// src/projectContext/projectContext.ts
+import { Effect as Effect5, FileSystem as FileSystem3, Path as Path2, Schema as Schema5 } from "effect";
+var load = (cwd) => Effect5.gen(function* () {
+  const fileSystem = yield* FileSystem3.FileSystem;
+  const path = yield* Path2.Path;
+  const cwdAbsolute = path.resolve(cwd);
+  const configPath = path.join(cwdAbsolute, "components.json");
+  const hasConfig = yield* fileSystem.exists(configPath);
+  if (!hasConfig) {
+    return yield* new ConfigNotFoundError({ cwd: cwdAbsolute });
+  }
+  const configJson = yield* readJsonFile(configPath);
+  const config = yield* Schema5.decodeUnknownEffect(exports_componentsConfig.Config)(configJson);
+  const context = {
+    cwd: cwdAbsolute,
+    config,
+    cssPath: path.resolve(cwdAbsolute, config.css),
+    uiDir: path.resolve(cwdAbsolute, config.aliases.ui),
+    libDir: path.resolve(cwdAbsolute, config.aliases.lib)
+  };
+  return context;
+});
+// src/registryClient/registryClient.ts
+import { Effect as Effect6, Option as Option2, Path as Path3, Schema as Schema6 } from "effect";
+var namePlaceholder = "{name}";
+var isUrl = (spec) => spec.includes("://");
+var isPathSpec = (spec) => spec.startsWith(".") || spec.startsWith("/") || spec.endsWith(".json");
+var templateFromLocation = (location, separator) => {
+  const lastSeparator = location.lastIndexOf(separator);
+  if (lastSeparator < 0) {
+    return `${namePlaceholder}.json`;
+  }
+  return `${location.slice(0, lastSeparator)}${separator}${namePlaceholder}.json`;
+};
+var normalizeTemplate = (registry2) => {
+  if (registry2.includes(namePlaceholder)) {
+    return registry2;
+  }
+  const trimmed = registry2.endsWith("/") ? registry2.slice(0, -1) : registry2;
+  return `${trimmed}/${namePlaceholder}.json`;
+};
+var makeGetItem = (options) => Effect6.gen(function* () {
+  const path = yield* Path3.Path;
+  const itemCache = new Map;
+  const keyTemplates = new Map;
+  const resolveLocation = (spec, maybeOrigin) => Effect6.gen(function* () {
+    if (isUrl(spec)) {
+      return { location: spec, template: templateFromLocation(spec, "/") };
+    }
+    if (isPathSpec(spec)) {
+      const location = path.resolve(options.cwd, spec);
+      return { location, template: templateFromLocation(location, path.sep) };
+    }
+    if (spec.startsWith("@")) {
+      const separator = spec.indexOf("/");
+      const namespace = separator < 0 ? spec : spec.slice(0, separator);
+      const name = separator < 0 ? "" : spec.slice(separator + 1);
+      const template2 = options.registries?.[namespace];
+      if (template2 === undefined) {
+        return yield* new RegistryNotConfiguredError({ namespace });
+      }
+      return { location: template2.replace(namePlaceholder, name), template: template2 };
+    }
+    const originTemplate = Option2.flatMap(maybeOrigin, (origin) => Option2.fromNullishOr(keyTemplates.get(origin)));
+    const template = Option2.getOrElse(originTemplate, () => options.defaultTemplate);
+    return { location: template.replace(namePlaceholder, spec), template };
+  });
+  const fetchItemJson = (location) => {
+    if (isUrl(location)) {
+      return Effect6.tryPromise({
+        try: async () => {
+          const response = await fetch(location);
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+          }
+          return response.json();
+        },
+        catch: (error2) => new RegistryFetchError({ spec: location, message: String(error2) })
+      });
+    }
+    return readJsonFile(location).pipe(Effect6.catchTag("PlatformError", (error2) => Effect6.fail(new RegistryFetchError({ spec: location, message: String(error2) }))));
+  };
+  const getItem = (spec, maybeOrigin) => Effect6.gen(function* () {
+    const resolved = yield* resolveLocation(spec, maybeOrigin);
+    keyTemplates.set(resolved.location, resolved.template);
+    const cached = itemCache.get(resolved.location);
+    if (cached !== undefined) {
+      const found = { key: resolved.location, item: cached };
+      return found;
+    }
+    const itemJson = yield* fetchItemJson(resolved.location);
+    const item = yield* Schema6.decodeUnknownEffect(exports_registry.Item)(itemJson);
+    itemCache.set(resolved.location, item);
+    const fetched = { key: resolved.location, item };
+    return fetched;
+  });
+  return getItem;
+});
+// src/styleWriter/styleWriter.ts
+import { Effect as Effect7, FileSystem as FileSystem5 } from "effect";
+var hasEntries = (record) => record !== undefined && Object.keys(record).length > 0;
+var applyStyles = (options) => Effect7.gen(function* () {
+  const hasWork = hasEntries(options.cssVars.theme) || hasEntries(options.cssVars.light) || hasEntries(options.cssVars.dark) || hasEntries(options.css);
+  if (!hasWork) {
+    return false;
+  }
+  const fileSystem = yield* FileSystem5.FileSystem;
+  const hasStylesheet = yield* fileSystem.exists(options.cssPath);
+  if (!hasStylesheet) {
+    return yield* new StylesheetNotFoundError({ path: options.cssPath });
+  }
+  const current = yield* fileSystem.readFileString(options.cssPath);
+  const merged = yield* exports_cssMerge.merge({
+    css: current,
+    cssVars: options.cssVars,
+    extraCss: options.css,
+    isOverwriting: options.isOverwriting
+  });
+  if (merged === current) {
+    return false;
+  }
+  yield* fileSystem.writeFileString(options.cssPath, merged);
+  return true;
+});
+// src/command/add/add.ts
+var componentsArgument = Argument.string("components").pipe(Argument.withDescription("Component names, @namespace/names, URLs, or paths"), Argument.variadic({ min: 1 }));
+var cwdFlag = Flag.string("cwd").pipe(Flag.withAlias("c"), Flag.withDescription("Working directory"), Flag.withDefault("."));
+var overwriteFlag = Flag.boolean("overwrite").pipe(Flag.withAlias("o"), Flag.withDescription("Overwrite existing files"));
+var dryRunFlag = Flag.boolean("dry-run").pipe(Flag.withDescription("Print the plan without writing anything"));
+var registryFlag = Flag.string("registry").pipe(Flag.withDescription("Registry URL template, URL, or local directory overriding the default registry"), Flag.optional);
+var stripRegistrySourcePrefix = (filePath) => {
+  const segments = filePath.split("/");
+  const registryIndex = segments.indexOf("registry");
+  if (registryIndex >= 0 && segments.length > registryIndex + 2) {
+    return segments.slice(registryIndex + 2).join("/");
+  }
+  return segments.at(-1) ?? filePath;
+};
+var planFiles = (context, files) => Effect8.gen(function* () {
+  const path = yield* Path4.Path;
+  const planned = [];
+  for (const file of files) {
+    const content = file.content ?? "";
+    if (file.target !== undefined) {
+      if (file.target.startsWith("/") || file.target.split("/").includes("..")) {
+        return yield* new UnsafeTargetError({ target: file.target });
+      }
+      const absolutePath2 = path.resolve(context.cwd, file.target);
+      planned.push({ absolutePath: absolutePath2, relativePath: file.target, content });
+      continue;
+    }
+    const relativeToKind = stripRegistrySourcePrefix(file.path);
+    const baseDir = file.type === "registry:lib" ? context.libDir : context.uiDir;
+    const absolutePath = path.resolve(baseDir, relativeToKind);
+    planned.push({ absolutePath, relativePath: path.relative(context.cwd, absolutePath), content });
+  }
+  return planned;
+});
+var runAdd = ({ components, cwd, dryRun, overwrite, registry: registry2 }) => Effect8.gen(function* () {
+  const fileSystem = yield* FileSystem6.FileSystem;
+  const path = yield* Path4.Path;
+  const context = yield* load(cwd);
+  const environmentTemplate = Option3.fromNullishOr(globalThis.process?.env?.[registryUrlEnvVar]);
+  const defaultTemplate = Option3.match(Option3.orElse(Option3.map(registry2, normalizeTemplate), () => environmentTemplate), {
+    onNone: () => defaultRegistryTemplate,
+    onSome: (template) => template
+  });
+  const getItem = yield* makeGetItem({
+    cwd: context.cwd,
+    defaultTemplate,
+    registries: context.config.registries
+  });
+  const tree = yield* exports_resolveTree.resolve(components, getItem);
+  for (const warning of tree.warnings) {
+    yield* Console.warn(warning);
+  }
+  const writableFiles = tree.files.filter((file) => file.type !== "registry:example");
+  const allPlanned = yield* planFiles(context, writableFiles);
+  const planned = [];
+  const conflicts = [];
+  for (const file of allPlanned) {
+    const exists = yield* fileSystem.exists(file.absolutePath);
+    if (!exists) {
+      planned.push(file);
+      continue;
+    }
+    const existing = yield* fileSystem.readFileString(file.absolutePath);
+    if (existing === file.content) {
+      continue;
+    }
+    if (overwrite) {
+      planned.push(file);
+    } else {
+      conflicts.push(file.relativePath);
+    }
+  }
+  if (conflicts.length > 0) {
+    return yield* new FileConflictError({ paths: conflicts });
+  }
+  if (dryRun) {
+    yield* Console.log(`Would write ${planned.length} files:`);
+    for (const file of planned) {
+      yield* Console.log(`  ${file.relativePath}`);
+    }
+    if (tree.dependencies.length > 0) {
+      yield* Console.log(`Would install: ${tree.dependencies.join(" ")}`);
+    }
+    if (tree.devDependencies.length > 0) {
+      yield* Console.log(`Would install (dev): ${tree.devDependencies.join(" ")}`);
+    }
+    return;
+  }
+  for (const file of planned) {
+    yield* fileSystem.makeDirectory(path.dirname(file.absolutePath), { recursive: true });
+    yield* fileSystem.writeFileString(file.absolutePath, file.content);
+  }
+  if (tree.dependencies.length > 0 || tree.devDependencies.length > 0) {
+    const packageManager = yield* detectPackageManager(context.cwd);
+    yield* install({
+      cwd: context.cwd,
+      packageManager,
+      dependencies: tree.dependencies,
+      devDependencies: tree.devDependencies
+    });
+  }
+  const hasThemeItem = tree.items.some((item) => item.type === "registry:theme");
+  const changedStylesheet = yield* applyStyles({
+    cssPath: context.cssPath,
+    cssVars: tree.cssVars,
+    css: tree.css,
+    isOverwriting: hasThemeItem
+  });
+  const summary = [
+    `Added ${tree.items.length} items (${planned.length} files)`,
+    ...changedStylesheet ? [`Updated ${context.config.css}`] : []
+  ];
+  for (const line of summary) {
+    yield* Console.log(line);
+  }
+});
+var addCommand = Command.make("add", {
+  components: componentsArgument,
+  cwd: cwdFlag,
+  dryRun: dryRunFlag,
+  overwrite: overwriteFlag,
+  registry: registryFlag
+}, ({ components, cwd, dryRun, overwrite, registry: registry2 }) => runAdd({ components, cwd, dryRun, overwrite, registry: registry2 })).pipe(Command.withDescription("Add components from a registry to your project"));
+// src/command/build/build.ts
+import { Console as Console2, Effect as Effect9, FileSystem as FileSystem7, Path as Path5, Schema as Schema7 } from "effect";
+import { Argument as Argument2, Command as Command2, Flag as Flag2 } from "effect/unstable/cli";
+var registryArgument = Argument2.string("registry").pipe(Argument2.withDescription("Path to the registry manifest"), Argument2.withDefault("./registry.json"));
+var outputFlag = Flag2.string("output").pipe(Flag2.withAlias("o"), Flag2.withDescription("Destination directory for built registry JSON"), Flag2.withDefault("./public/r"));
+var cwdFlag2 = Flag2.string("cwd").pipe(Flag2.withAlias("c"), Flag2.withDescription("Working directory"), Flag2.withDefault("."));
+var isLocalName = (spec) => !spec.includes("://") && !spec.startsWith("@") && !spec.startsWith(".") && !spec.startsWith("/");
+var validateLocalDependencies = (manifest) => Effect9.gen(function* () {
+  const names = new Set(manifest.items.map((item) => item.name));
+  for (const item of manifest.items) {
+    for (const dependency of item.registryDependencies ?? []) {
+      if (isLocalName(dependency) && !names.has(dependency)) {
+        return yield* new UnknownRegistryDependencyError({ itemName: item.name, dependency });
+      }
+    }
+  }
+});
+var buildCommand = Command2.make("build", { registry: registryArgument, output: outputFlag, cwd: cwdFlag2 }, ({ cwd, output, registry: registry2 }) => Effect9.gen(function* () {
+  const fileSystem = yield* FileSystem7.FileSystem;
+  const path = yield* Path5.Path;
+  const cwdAbsolute = path.resolve(cwd);
+  const manifestPath = path.resolve(cwdAbsolute, registry2);
+  const manifestJson = yield* readJsonFile(manifestPath);
+  const manifest = yield* Schema7.decodeUnknownEffect(exports_registry.Manifest)(manifestJson);
+  yield* validateLocalDependencies(manifest);
+  const outputDir = path.resolve(cwdAbsolute, output);
+  yield* fileSystem.makeDirectory(outputDir, { recursive: true });
+  for (const item of manifest.items) {
+    const files = yield* Effect9.forEach(item.files ?? [], (file) => Effect9.gen(function* () {
+      const content = yield* fileSystem.readFileString(path.resolve(cwdAbsolute, file.path));
+      return { ...file, content };
+    }));
+    const builtItem = {
+      ...item,
+      $schema: itemSchemaUrl,
+      ...files.length > 0 ? { files } : {}
+    };
+    const encoded = yield* Schema7.encodeEffect(exports_registry.Item)(builtItem);
+    const itemPath = path.join(outputDir, `${item.name}.json`);
+    yield* fileSystem.writeFileString(itemPath, `${JSON.stringify(encoded, null, 2)}
+`);
+  }
+  const encodedManifest = yield* Schema7.encodeEffect(exports_registry.Manifest)(manifest);
+  yield* fileSystem.writeFileString(path.join(outputDir, "registry.json"), `${JSON.stringify(encodedManifest, null, 2)}
+`);
+  yield* Console2.log(`Built ${manifest.items.length} items to ${path.relative(cwdAbsolute, outputDir)}`);
+})).pipe(Command2.withDescription("Build registry JSON from a registry.json manifest"));
+// src/command/init/init.ts
+import { Console as Console3, Effect as Effect10, FileSystem as FileSystem8, Path as Path6 } from "effect";
+import { Command as Command3, Flag as Flag3 } from "effect/unstable/cli";
+var cwdFlag3 = Flag3.string("cwd").pipe(Flag3.withAlias("c"), Flag3.withDescription("Working directory"), Flag3.withDefault("."));
+var cssFlag = Flag3.string("css").pipe(Flag3.withDescription("Path to the project stylesheet"), Flag3.withDefault(exports_componentsConfig.defaultCss));
+var baseColorFlag = Flag3.string("base-color").pipe(Flag3.withDescription("Base color theme"), Flag3.withDefault(exports_componentsConfig.defaultBaseColor));
+var forceFlag = Flag3.boolean("force").pipe(Flag3.withDescription("Overwrite an existing components.json"));
+var registryFlag2 = Flag3.string("registry").pipe(Flag3.withDescription("Registry URL template, URL, or local directory overriding the default registry"), Flag3.optional);
+var aliasPathsKey = "@/*";
+var aliasPathsValue = "./src/*";
+var injectTsconfigAlias = (cwd) => Effect10.gen(function* () {
+  const fileSystem = yield* FileSystem8.FileSystem;
+  const path = yield* Path6.Path;
+  const tsconfigPath = path.join(cwd, "tsconfig.json");
+  const hasTsconfig = yield* fileSystem.exists(tsconfigPath);
+  if (!hasTsconfig) {
+    yield* Console3.warn('No tsconfig.json found; add "paths": { "@/*": ["./src/*"] } manually');
+    return;
+  }
+  const parsed = yield* readJsonFile(tsconfigPath).pipe(Effect10.orElseSucceed(() => {
+    return;
+  }));
+  if (parsed === undefined || typeof parsed !== "object") {
+    yield* Console3.warn('Could not parse tsconfig.json; add "paths": { "@/*": ["./src/*"] } manually');
+    return;
+  }
+  const tsconfig = parsed;
+  const compilerOptions = tsconfig.compilerOptions ?? {};
+  const paths = compilerOptions["paths"] ?? {};
+  if (paths[aliasPathsKey] !== undefined) {
+    return;
+  }
+  const nextTsconfig = {
+    ...tsconfig,
+    compilerOptions: {
+      ...compilerOptions,
+      paths: { ...paths, [aliasPathsKey]: [aliasPathsValue] }
+    }
+  };
+  yield* writeJsonFile(tsconfigPath, nextTsconfig);
+  yield* Console3.log("Added @/* path alias to tsconfig.json");
+});
+var viteAliasBlock = [
+  "  resolve: {",
+  "    alias: [{ find: '@', replacement: fileURLToPath(new URL('./src', import.meta.url)) }],",
+  "  },"
+].join(`
+`);
+var injectViteAlias = (cwd) => Effect10.gen(function* () {
+  const fileSystem = yield* FileSystem8.FileSystem;
+  const path = yield* Path6.Path;
+  const viteConfigPath = path.join(cwd, "vite.config.ts");
+  const hasViteConfig = yield* fileSystem.exists(viteConfigPath);
+  if (!hasViteConfig) {
+    yield* Console3.warn("No vite.config.ts found; add a resolve.alias mapping '@' to ./src manually");
+    return;
+  }
+  const source = yield* fileSystem.readFileString(viteConfigPath);
+  if (source.includes("resolve:") || source.includes("find: '@'")) {
+    return;
+  }
+  const anchor = `export default defineConfig({
+`;
+  if (!source.includes(anchor)) {
+    yield* Console3.warn("Could not update vite.config.ts; add a resolve.alias mapping '@' to ./src manually");
+    return;
+  }
+  const withAlias = source.replace(anchor, `${anchor}${viteAliasBlock}
+`);
+  const withImport = withAlias.includes("from 'node:url'") ? withAlias : `import { fileURLToPath } from 'node:url'
+${withAlias}`;
+  yield* fileSystem.writeFileString(viteConfigPath, withImport);
+  yield* Console3.log("Added @ resolve alias to vite.config.ts");
+});
+var initCommand = Command3.make("init", {
+  baseColor: baseColorFlag,
+  css: cssFlag,
+  cwd: cwdFlag3,
+  force: forceFlag,
+  registry: registryFlag2
+}, ({ baseColor, css, cwd, force, registry: registry2 }) => Effect10.gen(function* () {
+  const fileSystem = yield* FileSystem8.FileSystem;
+  const path = yield* Path6.Path;
+  const cwdAbsolute = path.resolve(cwd);
+  const hasPackageJson = yield* fileSystem.exists(path.join(cwdAbsolute, "package.json"));
+  if (!hasPackageJson) {
+    return yield* new ConfigNotFoundError({ cwd: cwdAbsolute });
+  }
+  const packageJson = yield* readJsonFile(path.join(cwdAbsolute, "package.json")).pipe(Effect10.orElseSucceed(() => ({})));
+  const dependencies = packageJson.dependencies ?? {};
+  if (dependencies["foldkit"] === undefined) {
+    yield* Console3.warn("foldkit is not a dependency of this project; foldcn components require a FoldKit app");
+  }
+  const configPath = path.join(cwdAbsolute, "components.json");
+  const hasConfig = yield* fileSystem.exists(configPath);
+  if (hasConfig && !force) {
+    yield* Console3.warn("components.json already exists; pass --force to overwrite");
+    return;
+  }
+  yield* writeJsonFile(configPath, {
+    $schema: componentsSchemaUrl,
+    css,
+    baseColor,
+    aliases: exports_componentsConfig.defaultAliases
+  });
+  yield* Console3.log("Wrote components.json");
+  yield* injectTsconfigAlias(cwdAbsolute);
+  yield* injectViteAlias(cwdAbsolute);
+  const hasStylesheet = yield* fileSystem.exists(path.resolve(cwdAbsolute, css));
+  if (!hasStylesheet) {
+    yield* fileSystem.makeDirectory(path.dirname(path.resolve(cwdAbsolute, css)), { recursive: true });
+    yield* fileSystem.writeFileString(path.resolve(cwdAbsolute, css), `@import 'tailwindcss';
+`);
+    yield* Console3.log(`Created ${css}`);
+  }
+  yield* runAdd({
+    components: [`theme-${baseColor}`, "utils"],
+    cwd: cwdAbsolute,
+    dryRun: false,
+    overwrite: true,
+    registry: registry2
+  });
+  yield* Console3.log("Project initialized. Try: foldcn add button");
+})).pipe(Command3.withDescription("Initialize components.json and the base theme in a FoldKit project"));
+// src/cli.ts
+var version = "0.0.0";
+var command = Command4.make("foldcn").pipe(Command4.withDescription("shadcn-style component distribution for FoldKit"), Command4.withSubcommands([addCommand, buildCommand, initCommand]));
+var run = Effect11.fn("FoldcnCli.run")(function* (argv) {
+  return yield* Command4.runWith(command, { version })(argv);
+});
+var main = Command4.run(command, { version });
+
+// src/bin.ts
+NodeRuntime.runMain(main.pipe(Effect12.provide(NodeServices.layer)));

package/package.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "foldcn",
+  "version": "0.0.1",
+  "description": "shadcn-style CLI for FoldKit: add copy-in components from a registry",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "foldcn": "./dist/bin.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun build src/bin.ts --outdir dist --target node --format esm --external effect --external @effect/platform-node --external postcss",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@effect/platform-node": "4.0.0-beta.88",
+    "effect": "4.0.0-beta.88",
+    "postcss": "8.5.16"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-beta.88",
+    "@foldcn/registry": "0.0.0",
+    "@types/node": "24.12.2",
+    "typescript": "6.0.3",
+    "vitest": "4.1.9"
+  }
+}