@organcli/composed-cli 0.1.0 → 0.1.1

package/dist/index.js

@@ -10,6 +10,30 @@ import pc from "picocolors";
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { dirname as dirname2, join as join4, relative } from "path";
 
+// src/lib/controllers.ts
+var CONTROLLERS_PREFIX = "src/components/common/controllers/";
+function toKebabCase(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function findControllerPath(source, exportName) {
+  const guessed = `${CONTROLLERS_PREFIX}${toKebabCase(exportName)}.tsx`;
+  if (source.hasFile(guessed) && source.readFile(guessed).includes(`export function ${exportName}`)) {
+    return guessed;
+  }
+  for (const path of source.listFiles(CONTROLLERS_PREFIX)) {
+    if (!path.endsWith(".tsx")) continue;
+    if (path.endsWith("/index.tsx") || path.endsWith("/index.ts")) continue;
+    if (source.readFile(path).includes(`export function ${exportName}`)) {
+      return path;
+    }
+  }
+  return void 0;
+}
+function controllerBarrelExport(exportName, relPath) {
+  const fileName = relPath.split("/").pop().replace(/\.tsx?$/, "");
+  return `export { ${exportName} } from './${fileName}';`;
+}
+
 // src/lib/i18n.ts
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { join as join2 } from "path";
@@ -37,6 +61,7 @@ function loadFromBundle() {
   );
   return {
     registry: bundle.registry,
+    featureRegistry: bundle.featureRegistry ?? [],
     readFile: (path) => {
       const content = bundle.files[path];
       if (content === void 0) {
@@ -44,22 +69,34 @@ function loadFromBundle() {
       }
       return content;
     },
+    hasFile: (path) => path in bundle.files,
+    listFiles: (prefix) => Object.keys(bundle.files).filter((p) => p === prefix || p.startsWith(prefix)),
     readMessages: (locale) => bundle.messages[locale] ?? {}
   };
 }
 async function loadFromBoilerplateTree() {
-  const boilerplateRoot = findAncestorContaining(
-    here,
-    join("src", "registry", "components.ts")
-  );
+  const boilerplateRoot = overrideRoot ?? findAncestorContaining(here, join("src", "registry", "components.ts"));
   if (!boilerplateRoot) return void 0;
+  if (!existsSync(join(boilerplateRoot, "src", "registry", "components.ts"))) {
+    return void 0;
+  }
   const registryPath = join(boilerplateRoot, "src", "registry", "components.ts");
   const mod = await import(
     /* @vite-ignore */
     pathToFileURL(registryPath).href
   );
+  const featuresPath = join(boilerplateRoot, "src", "registry", "features.ts");
+  let featureRegistry = [];
+  if (existsSync(featuresPath)) {
+    const featuresMod = await import(
+      /* @vite-ignore */
+      pathToFileURL(featuresPath).href
+    );
+    featureRegistry = featuresMod.featureRegistry;
+  }
   return {
     registry: mod.componentRegistry,
+    featureRegistry,
     readFile: (path) => {
       const abs = join(boilerplateRoot, path);
       if (!existsSync(abs)) {
@@ -67,28 +104,54 @@ async function loadFromBoilerplateTree() {
       }
       return readFileSync(abs, "utf-8");
     },
+    hasFile: (path) => existsSync(join(boilerplateRoot, path)),
+    listFiles: (prefix) => listFilesFromTree(boilerplateRoot, prefix),
     readMessages: (locale) => readMessagesFromTree(boilerplateRoot, locale)
   };
 }
+function listFilesFromTree(boilerplateRoot, prefix) {
+  const abs = join(boilerplateRoot, prefix);
+  if (!existsSync(abs)) return [];
+  const out = [];
+  for (const entry of readdirSync(abs, { withFileTypes: true })) {
+    const rel = `${prefix.replace(/\\/g, "/").replace(/\/$/, "")}/${entry.name}`;
+    if (entry.isDirectory()) {
+      out.push(...listFilesFromTree(boilerplateRoot, rel));
+    } else {
+      out.push(rel);
+    }
+  }
+  return out;
+}
 function readMessagesFromTree(boilerplateRoot, locale) {
   const dir = join(boilerplateRoot, "messages", locale);
   const out = {};
   if (!existsSync(dir)) return out;
   for (const file of readdirSync(dir)) {
     if (!file.endsWith(".json")) continue;
-    const namespace = file.replace(/\.json$/, "");
     const json = JSON.parse(readFileSync(join(dir, file), "utf-8"));
     for (const [key, value] of Object.entries(json)) {
       if (key === "$schema") continue;
-      out[`${namespace}_${key}`] = String(value);
+      out[key] = String(value);
     }
   }
   return out;
 }
 var cached;
+var overrideRoot;
+function setSourceRoot(root) {
+  cached = void 0;
+  overrideRoot = root;
+}
+function getSourceRoot() {
+  return overrideRoot;
+}
+function resolveSourceRoot() {
+  return overrideRoot ?? findAncestorContaining(here, join("src", "registry", "components.ts"));
+}
 async function getComponentSource() {
   if (cached) return cached;
-  const source = loadFromBundle() ?? await loadFromBoilerplateTree();
+  const source = overrideRoot ? await loadFromBoilerplateTree() : loadFromBundle() ?? await loadFromBoilerplateTree();
   if (!source) {
     throw new Error(
       "Could not locate component source. Expected either a built dist/registry-bundle.json (published package) or a sibling src/registry/components.ts (running inside the boilerplate repo)."
@@ -205,8 +268,41 @@ async function copyComponentFiles(cwd, entry, opts) {
     writeFileSync2(targetPath, content, "utf-8");
     results.push({ entryName: entry.name, targetPath, skipped: false });
   }
+  if (entry.controller) {
+    const controller = await copyController(cwd, entry, opts);
+    if (controller) results.push(controller);
+  }
   return results;
 }
+async function copyController(cwd, entry, opts) {
+  if (!entry.controller) return void 0;
+  const source = await getComponentSource();
+  const controllerPath = findControllerPath(source, entry.controller);
+  if (!controllerPath) {
+    throw new Error(
+      `Could not find controller file for ${entry.name} (${entry.controller})`
+    );
+  }
+  const aliases = readTargetAliases(cwd);
+  const fileName = controllerPath.split("/").pop();
+  const targetPath = join4(
+    aliasToPath(cwd, aliases.components),
+    "common",
+    "controllers",
+    fileName
+  );
+  if (existsSync4(targetPath) && !opts.overwrite) {
+    return {
+      entryName: entry.controller,
+      targetPath,
+      skipped: true,
+      reason: "already exists (use --overwrite to replace)"
+    };
+  }
+  mkdirSync2(dirname2(targetPath), { recursive: true });
+  writeFileSync2(targetPath, source.readFile(controllerPath), "utf-8");
+  return { entryName: entry.controller, targetPath, skipped: false };
+}
 async function copyLocalUtil(cwd, localDep, opts) {
   if (localDep !== "@/lib/utils") return void 0;
   const source = await getComponentSource();
@@ -294,6 +390,10 @@ function installNpmPackages(cwd, packages, pm) {
   return { ok: true };
 }
 
+// src/lib/resolve.ts
+import { existsSync as existsSync6 } from "fs";
+import { dirname as dirname3, isAbsolute, relative as relative2, resolve } from "path";
+
 // src/lib/registry.ts
 async function loadRegistry() {
   const source = await getComponentSource();
@@ -316,6 +416,20 @@ async function resolveQueries(queries) {
   const ambiguous = {};
   const seen = /* @__PURE__ */ new Set();
   for (const query of queries) {
+    const fromPath = looksLikePath(query) ? await findComponentsByPath(query) : void 0;
+    if (fromPath) {
+      if (fromPath.length === 0) {
+        notFound.push(query);
+        continue;
+      }
+      for (const match2 of fromPath) {
+        if (!seen.has(match2.name)) {
+          seen.add(match2.name);
+          entries.push(match2);
+        }
+      }
+      continue;
+    }
     const match = await findComponent(query);
     if (!match) {
       notFound.push(query);
@@ -353,13 +467,58 @@ function unionDependencies(entries) {
 async function allComponentNames() {
   return (await loadRegistry()).map((e) => `${e.name} (${e.slug})`);
 }
+function looksLikePath(query) {
+  return isAbsolute(query) || /[\\/]/.test(query);
+}
+function toPosix(query) {
+  return query.replace(/\\/g, "/").replace(/\/$/, "");
+}
+function registryPrefixes(query) {
+  const posix = toPosix(query);
+  if (!posix || isAbsolute(query)) return [];
+  const prefixes = [posix];
+  if (!posix.startsWith("src/")) prefixes.push(`src/${posix}`);
+  return prefixes;
+}
+function matchesPrefix(filePath, prefix) {
+  return filePath === prefix || filePath.startsWith(`${prefix}/`);
+}
+function findBoilerplateRoot(start) {
+  let dir = start;
+  for (let i = 0; i <= 8; i++) {
+    if (existsSync6(resolve(dir, "src", "registry", "components.ts"))) return dir;
+    const parent = dirname3(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+  return void 0;
+}
+function queryToRelPath(query) {
+  const base = getSourceRoot() ?? process.cwd();
+  const abs = isAbsolute(query) ? query : resolve(base, query);
+  if (!existsSync6(abs)) return void 0;
+  const root = getSourceRoot() ?? findBoilerplateRoot(abs) ?? findBoilerplateRoot(process.cwd());
+  if (!root) return void 0;
+  const rel = relative2(root, abs).split("\\").join("/");
+  if (!rel || rel.startsWith("..")) return void 0;
+  return rel.replace(/\/$/, "");
+}
+async function findComponentsByPath(query) {
+  const rel = queryToRelPath(query);
+  const prefixes = rel ? [rel] : registryPrefixes(query);
+  if (prefixes.length === 0) return void 0;
+  const registry = await loadRegistry();
+  return registry.filter(
+    (entry) => entry.files.some((file) => prefixes.some((prefix) => matchesPrefix(file.path, prefix)))
+  );
+}
 
 // src/lib/shadcn.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { join as join6 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 function hasShadcnConfig(cwd) {
-  return existsSync6(join6(cwd, "components.json"));
+  return existsSync7(join6(cwd, "components.json"));
 }
 function installShadcnPrimitives(cwd, slugs, pm) {
   if (slugs.length === 0) return [];
@@ -378,11 +537,11 @@ function installShadcnPrimitives(cwd, slugs, pm) {
 }
 
 // src/lib/validate-install.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
 function validateCopiedFiles(files) {
   const issues = [];
   for (const file of files) {
-    if (!existsSync7(file.targetPath)) {
+    if (!existsSync8(file.targetPath)) {
       issues.push({ file: file.targetPath, message: "file was not written" });
       continue;
     }
@@ -523,12 +682,487 @@ async function runAdd(queries, options) {
 Done. Installed ${entries.length} component(s).`)));
 }
 
+// src/commands/create.ts
+import { existsSync as existsSync12 } from "fs";
+import pc2 from "picocolors";
+
+// src/lib/framework-detect.ts
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
+function readPackageJson(cwd) {
+  const pkgPath = join7(cwd, "package.json");
+  if (!existsSync9(pkgPath)) return void 0;
+  try {
+    return JSON.parse(readFileSync5(pkgPath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function allDeps(pkg) {
+  return { ...pkg.dependencies, ...pkg.devDependencies };
+}
+function detectTargetFramework(cwd) {
+  const pkg = readPackageJson(cwd);
+  if (pkg) {
+    const deps = allDeps(pkg);
+    if ("@tanstack/react-start" in deps || "@tanstack/start" in deps) {
+      return {
+        framework: "tanstack",
+        reason: "package.json depends on @tanstack/react-start"
+      };
+    }
+    if ("next" in deps) {
+      return { framework: "nextjs", reason: "package.json depends on next" };
+    }
+  }
+  if (existsSync9(join7(cwd, "next.config.js")) || existsSync9(join7(cwd, "next.config.ts")) || existsSync9(join7(cwd, "next.config.mjs"))) {
+    return { framework: "nextjs", reason: "found a next.config.* file" };
+  }
+  if (existsSync9(join7(cwd, "app")) && (existsSync9(join7(cwd, "app", "layout.tsx")) || existsSync9(join7(cwd, "app", "layout.js")))) {
+    return { framework: "nextjs", reason: "found app/layout.tsx (Next.js App Router)" };
+  }
+  if (existsSync9(join7(cwd, "src", "app")) && (existsSync9(join7(cwd, "src", "app", "layout.tsx")) || existsSync9(join7(cwd, "src", "app", "layout.js")))) {
+    return { framework: "nextjs", reason: "found src/app/layout.tsx (Next.js App Router)" };
+  }
+  if (existsSync9(join7(cwd, "src", "routeTree.gen.ts"))) {
+    return {
+      framework: "tanstack",
+      reason: "found src/routeTree.gen.ts (TanStack Router)"
+    };
+  }
+  if (existsSync9(join7(cwd, "src", "routes")) && existsSync9(join7(cwd, "src", "router.tsx"))) {
+    return {
+      framework: "tanstack",
+      reason: "found src/routes and src/router.tsx (TanStack Start layout)"
+    };
+  }
+  return void 0;
+}
+
+// src/lib/feature-registry.ts
+async function loadFeatureRegistry() {
+  const source = await getComponentSource();
+  return source.featureRegistry;
+}
+async function findFeature(name) {
+  const registry = await loadFeatureRegistry();
+  return registry.find((e) => e.name === name);
+}
+async function listFeatureNames() {
+  return (await loadFeatureRegistry()).map((e) => e.name);
+}
+function frameworkLabel(framework) {
+  return framework === "tanstack" ? "TanStack Start" : "Next.js";
+}
+function supportedFrameworksFor(entry) {
+  return Object.keys(entry.frameworks);
+}
+
+// src/lib/install-feature.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4, join as join8 } from "path";
+function nextAppDir(cwd) {
+  if (existsSync10(join8(cwd, "src", "app"))) return "src/app";
+  if (existsSync10(join8(cwd, "app"))) return "app";
+  if (existsSync10(join8(cwd, "src"))) return "src/app";
+  return "app";
+}
+function toFeatureTargetPath(cwd, sourceRelPath, impl, framework) {
+  let rel = sourceRelPath.replace(/\\/g, "/");
+  const prefix = impl.sourcePrefix?.replace(/\\/g, "/");
+  if (prefix && rel.startsWith(prefix)) rel = rel.slice(prefix.length);
+  if (framework === "nextjs" && (rel === "src/app" || rel.startsWith("src/app/"))) {
+    const appDir = nextAppDir(cwd);
+    if (appDir === "app") rel = rel.replace(/^src\/app/, "app");
+  }
+  return rel;
+}
+function adaptContent(content, framework) {
+  if (framework !== "nextjs") return content;
+  return rewriteParaglideUsage(content, "@/lib/composed-strings").replaceAll("#/", "@/");
+}
+function sourceContent(source, relPath, framework) {
+  return adaptContent(source.readFile(relPath), framework);
+}
+function fileMatchesSource(cwd, sourceRelPath, targetRelPath, source, framework) {
+  const targetPath = join8(cwd, targetRelPath);
+  if (!existsSync10(targetPath)) return false;
+  return readFileSync6(targetPath, "utf-8") === sourceContent(source, sourceRelPath, framework);
+}
+async function installFeatureFiles(cwd, impl, opts) {
+  const source = await getComponentSource();
+  const results = [];
+  for (const relPath of impl.files) {
+    const targetRel = toFeatureTargetPath(cwd, relPath, impl, opts.framework);
+    const targetPath = join8(cwd, targetRel);
+    if (existsSync10(targetPath) && !opts.overwrite) {
+      if (fileMatchesSource(cwd, relPath, targetRel, source, opts.framework)) {
+        results.push({
+          path: targetRel,
+          status: "skipped",
+          reason: "already installed (identical)"
+        });
+      } else {
+        results.push({
+          path: targetRel,
+          status: "skipped",
+          reason: "already exists (use --overwrite to replace)"
+        });
+      }
+      continue;
+    }
+    const content = sourceContent(source, relPath, opts.framework);
+    mkdirSync3(dirname4(targetPath), { recursive: true });
+    writeFileSync3(targetPath, content, "utf-8");
+    results.push({ path: targetRel, status: "added" });
+  }
+  return results;
+}
+async function findFeatureFileConflicts(cwd, impl, framework) {
+  const source = await getComponentSource();
+  const conflicts = [];
+  for (const relPath of impl.files) {
+    const targetRel = toFeatureTargetPath(cwd, relPath, impl, framework);
+    if (existsSync10(join8(cwd, targetRel)) && !fileMatchesSource(cwd, relPath, targetRel, source, framework)) {
+      conflicts.push(targetRel);
+    }
+  }
+  return conflicts;
+}
+
+// src/lib/move-files.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync7, readdirSync as readdirSync2, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname5, join as join9 } from "path";
+async function copyEntryToRepo(destRoot, entry, opts) {
+  const source = await getComponentSource();
+  const results = [];
+  for (const file of entry.files) {
+    results.push(writeRelPath(destRoot, file.path, source.readFile(file.path), entry.name, opts));
+  }
+  if (entry.controller) {
+    const controllerPath = findControllerPath(source, entry.controller);
+    if (!controllerPath) {
+      throw new Error(
+        `Could not find controller file for ${entry.name} (${entry.controller})`
+      );
+    }
+    results.push(
+      writeRelPath(
+        destRoot,
+        controllerPath,
+        source.readFile(controllerPath),
+        entry.controller,
+        opts
+      )
+    );
+    upsertControllerBarrel(destRoot, entry.controller, controllerPath, results);
+  }
+  return results;
+}
+async function mergeI18nIntoRepo(destRoot, keys) {
+  if (keys.length === 0) return { added: [] };
+  const messagesRoot = join9(destRoot, "messages");
+  const source = await getComponentSource();
+  const added = [];
+  for (const locale of ["en", "ar"]) {
+    const localeDir = join9(messagesRoot, locale);
+    const messages = source.readMessages(locale);
+    const namespaces = existsSync11(localeDir) ? readdirSync2(localeDir).filter((file) => file.endsWith(".json")).map((file) => file.replace(/\.json$/, "")) : [];
+    const grouped = {};
+    for (const key of keys) {
+      if (!(key in messages)) continue;
+      const ns = namespaceForKey(key, namespaces);
+      grouped[ns] ??= {};
+      grouped[ns][key] = messages[key];
+    }
+    for (const [ns, kvs] of Object.entries(grouped)) {
+      const filePath = join9(localeDir, `${ns}.json`);
+      const existing = existsSync11(filePath) ? JSON.parse(readFileSync7(filePath, "utf-8")) : { $schema: "https://inlang.com/schema/inlang-message-format" };
+      for (const [key, value] of Object.entries(kvs)) {
+        if (!(key in existing)) added.push(`${locale}/${ns}.json#${key}`);
+        existing[key] = value;
+      }
+      const schema = existing.$schema;
+      delete existing.$schema;
+      const sorted = Object.fromEntries(
+        Object.keys(existing).sort().map((key) => [key, existing[key]])
+      );
+      const out = schema ? { $schema: schema, ...sorted } : sorted;
+      mkdirSync4(dirname5(filePath), { recursive: true });
+      writeFileSync4(filePath, JSON.stringify(out, null, 2) + "\n", "utf-8");
+    }
+  }
+  return { added };
+}
+function writeRelPath(destRoot, relPath, content, entryName, opts) {
+  const targetPath = join9(destRoot, relPath);
+  if (existsSync11(targetPath) && !opts.overwrite) {
+    return {
+      entryName,
+      targetPath,
+      skipped: true,
+      reason: "already exists (use --overwrite to replace)"
+    };
+  }
+  mkdirSync4(dirname5(targetPath), { recursive: true });
+  writeFileSync4(targetPath, content, "utf-8");
+  return { entryName, targetPath, skipped: false };
+}
+function upsertControllerBarrel(destRoot, exportName, controllerPath, results) {
+  const barrelRel = "src/components/common/controllers/index.ts";
+  const barrelAbs = join9(destRoot, barrelRel);
+  const line = controllerBarrelExport(exportName, controllerPath);
+  const existing = existsSync11(barrelAbs) ? readFileSync7(barrelAbs, "utf-8") : "";
+  if (existing.includes(`export { ${exportName} }`)) return;
+  const next = existing.trimEnd() ? `${existing.replace(/\s*$/, "\n")}${line}
+` : `${line}
+`;
+  mkdirSync4(dirname5(barrelAbs), { recursive: true });
+  writeFileSync4(barrelAbs, next, "utf-8");
+  results.push({ entryName: exportName, targetPath: barrelAbs, skipped: false });
+}
+function namespaceForKey(key, namespaces) {
+  const existing = namespaces.filter((ns) => key === ns || key.startsWith(`${ns}_`)).sort((a, b) => b.length - a.length)[0];
+  if (existing) return existing;
+  const underscoreIndex = key.indexOf("_");
+  return underscoreIndex === -1 ? key : key.slice(0, underscoreIndex);
+}
+
+// src/commands/create.ts
+async function runCreateFeature(featureName, options) {
+  const { cwd } = options;
+  if (!featureName) {
+    console.error(pc2.red("Usage: composed-cli create feature <name> [--protected|--public]"));
+    process.exitCode = 1;
+    return;
+  }
+  if (options.protected && options.public) {
+    console.error(pc2.red("Pass either --protected or --public, not both."));
+    process.exitCode = 1;
+    return;
+  }
+  if (!existsSync12(cwd)) {
+    console.error(pc2.red(`Target directory does not exist: ${cwd}`));
+    process.exitCode = 1;
+    return;
+  }
+  const feature = await findFeature(featureName);
+  if (!feature) {
+    const available = await listFeatureNames();
+    console.error(pc2.red(`Feature "${featureName}" is not available in the boilerplate.`));
+    console.error("");
+    console.error(pc2.bold("Available features:"));
+    for (const name of available) console.error(pc2.dim(`  - ${name}`));
+    process.exitCode = 1;
+    return;
+  }
+  const detected = detectTargetFramework(cwd);
+  if (!detected) {
+    console.error(
+      pc2.red(
+        `Could not detect the target project's framework at ${cwd}. Expected to find a package.json with a recognizable framework dependency (e.g. "next" or "@tanstack/react-start"), or matching project structure.`
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const impl = feature.frameworks[detected.framework];
+  if (!impl) {
+    const supported = supportedFrameworksFor(feature);
+    console.error(
+      pc2.red(
+        `Feature "${feature.name}" exists, but ${frameworkLabel(detected.framework)} is not currently supported for this feature.`
+      )
+    );
+    console.error("");
+    console.error(pc2.bold("Supported frameworks:"));
+    for (const fw of supported) console.error(pc2.dim(`  - ${frameworkLabel(fw)}`));
+    process.exitCode = 1;
+    return;
+  }
+  const requestedScope = options.protected ? "protected" : options.public ? "public" : void 0;
+  if (requestedScope && impl.routeScope && requestedScope !== impl.routeScope) {
+    console.error(
+      pc2.red(
+        `--${requestedScope} does not apply to "${feature.name}" for ${frameworkLabel(detected.framework)}: this implementation's route is fixed at "${impl.routeScope}".`
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (requestedScope && !impl.routeScope) {
+    console.error(
+      pc2.red(
+        `--${requestedScope} does not apply to "${feature.name}" for ${frameworkLabel(detected.framework)}: this implementation has no protected/public route distinction.`
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  console.log(pc2.dim(`Detected framework: ${frameworkLabel(detected.framework)} (${detected.reason})`));
+  const conflicts = await findFeatureFileConflicts(cwd, impl, detected.framework);
+  if (conflicts.length > 0 && !options.overwrite) {
+    console.error(
+      pc2.red(`Feature "${feature.name}" already exists \u2014 the following file(s) already have different content:`)
+    );
+    for (const conflict of conflicts) {
+      console.error(pc2.red(`  ${conflict}`));
+    }
+    console.error("");
+    console.error(pc2.dim("Pass --overwrite to replace them."));
+    process.exitCode = 1;
+    return;
+  }
+  if (conflicts.length > 0) {
+    console.log(pc2.yellow(`Overwriting ${conflicts.length} existing file(s).`));
+  }
+  console.log(pc2.bold(`\u2714 Feature: ${feature.name}`));
+  console.log(pc2.bold(`\u2714 Framework implementation: ${frameworkLabel(detected.framework)}`));
+  const copied = await installFeatureFiles(cwd, impl, {
+    overwrite: options.overwrite,
+    framework: detected.framework
+  });
+  for (const file of copied) {
+    if (file.status === "skipped") {
+      console.log(pc2.yellow(`  skip  ${file.path} (${file.reason})`));
+    } else {
+      console.log(pc2.green(`  add   ${toDisplayPath(cwd, `${cwd}/${file.path}`)}`));
+    }
+  }
+  if (detected.framework === "nextjs") {
+    const i18n = await installI18nStrings(cwd, impl.i18nKeys);
+    if (i18n.addedKeys.length > 0) {
+      console.log(pc2.green(`  add   ${i18n.path} (${i18n.addedKeys.length} key(s))`));
+    }
+  } else {
+    const i18n = await mergeI18nIntoRepo(cwd, impl.i18nKeys);
+    if (i18n.added.length > 0) {
+      console.log(pc2.green(`  add   messages/ (${i18n.added.length} key(s))`));
+    }
+  }
+  console.log("");
+  console.log(pc2.bold(pc2.green(`Done. Installed feature "${feature.name}" (${frameworkLabel(detected.framework)}) into ${cwd}.`)));
+  if (detected.framework === "tanstack") {
+    console.log(
+      pc2.dim(
+        "Restart `bun run dev` (or run a build) so paraglideVitePlugin regenerates src/paraglide/ with any new message keys."
+      )
+    );
+  }
+}
+
+// src/commands/move.ts
+import { existsSync as existsSync13, statSync } from "fs";
+import { resolve as resolve2 } from "path";
+import pc3 from "picocolors";
+async function runMove(queries, options) {
+  if (queries.length === 0) {
+    console.error(
+      pc3.red(
+        "Usage: composed-cli move <component-or-path> [--to <repo>]"
+      )
+    );
+    console.error("");
+    console.error("Pass a registry name (labeled-select) or a path like components/ui.");
+    console.error("Available components:");
+    for (const name of await allComponentNames()) console.error(`  ${name}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (options.from) {
+    const fromRoot = resolve2(options.from);
+    if (!existsSync13(fromRoot) || !statSync(fromRoot).isDirectory()) {
+      console.error(pc3.red(`Source is not a directory: ${fromRoot}`));
+      process.exitCode = 1;
+      return;
+    }
+    setSourceRoot(fromRoot);
+  }
+  const destRoot = resolve2(options.to);
+  if (!existsSync13(destRoot) || !statSync(destRoot).isDirectory()) {
+    console.error(pc3.red(`Destination is not a directory: ${destRoot}`));
+    process.exitCode = 1;
+    return;
+  }
+  const sourceRoot = resolveSourceRoot();
+  if (sourceRoot && resolve2(sourceRoot) === destRoot) {
+    console.error(pc3.red("Source and destination are the same repository."));
+    console.error("Pass --to <other-repo>, for example:");
+    console.error(
+      pc3.cyan("  npx tsx cli/src/index.ts move src/components/ui --to M:\\my-next-app")
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const { entries, notFound, ambiguous } = await resolveQueries(queries);
+  if (notFound.length > 0) {
+    console.error(pc3.red(`Unknown component(s): ${notFound.join(", ")}`));
+    console.error(
+      pc3.dim(
+        "Use a name like labeled-select, or a path like components/ui. No local boilerplate is required."
+      )
+    );
+  }
+  for (const [query, names] of Object.entries(ambiguous)) {
+    console.error(
+      pc3.red(
+        `"${query}" matches multiple components: ${names.join(", ")}. Use one of those exact names.`
+      )
+    );
+  }
+  if (entries.length === 0) {
+    process.exitCode = 1;
+    return;
+  }
+  if (!existsSync13(resolve2(destRoot, ".git"))) {
+    console.log(pc3.yellow(`Warning: ${destRoot} has no .git directory.`));
+  }
+  if (hasShadcnConfig(destRoot)) {
+    await runAdd(
+      entries.map((e) => e.name),
+      {
+        cwd: destRoot,
+        overwrite: options.overwrite,
+        skipShadcn: false,
+        skipNpm: false,
+        skipI18n: false
+      }
+    );
+    return;
+  }
+  console.log(
+    pc3.bold(`Moving into ${destRoot}: ${entries.map((e) => e.name).join(", ")}`)
+  );
+  for (const entry of entries) {
+    const copied = await copyEntryToRepo(destRoot, entry, {
+      overwrite: options.overwrite
+    });
+    for (const file of copied) {
+      if (file.skipped) {
+        console.log(pc3.yellow(`  skip  ${toDisplayPath(destRoot, file.targetPath)} (${file.reason})`));
+      } else {
+        console.log(pc3.green(`  add   ${toDisplayPath(destRoot, file.targetPath)}`));
+      }
+    }
+  }
+  const deps = unionDependencies(entries);
+  const i18n = await mergeI18nIntoRepo(destRoot, deps.i18nKeys);
+  if (i18n.added.length > 0) {
+    console.log(pc3.green(`  add   messages/ (${i18n.added.length} key(s))`));
+  }
+  console.log(pc3.bold(pc3.green(`
+Done. Copied ${entries.length} component(s) into ${destRoot}.`)));
+}
+
 // src/index.ts
 var program = new Command();
 program.name("composed-cli").description(
   "Install individual composed UI components from the BIM frontend boilerplate into a Next.js + shadcn project."
-).version("0.1.0");
-program.command("add").description("Add one or more composed components to the current project").argument("<components...>", "component name(s) or slug(s), e.g. select dialog table").option("-c, --cwd <path>", "target project directory", process.cwd()).option("-o, --overwrite", "overwrite files that already exist", false).option("--skip-shadcn", "do not run `shadcn add` for required primitives", false).option("--skip-npm", "do not install required npm packages", false).option("--skip-i18n", "do not generate the local i18n strings file", false).action(async (components, opts) => {
+).version("0.1.1");
+program.command("add").description("Add one or more composed components to the current project").argument(
+  "<components...>",
+  "component name(s), slug(s), or path(s) like labeled-select or components/ui"
+).option("-c, --cwd <path>", "target project directory", process.cwd()).option("-o, --overwrite", "overwrite files that already exist", false).option("--skip-shadcn", "do not run `shadcn add` for required primitives", false).option("--skip-npm", "do not install required npm packages", false).option("--skip-i18n", "do not generate the local i18n strings file", false).action(async (components, opts) => {
   await runAdd(components, {
     cwd: opts.cwd,
     overwrite: opts.overwrite,
@@ -537,4 +1171,71 @@ program.command("add").description("Add one or more composed components to the c
     skipI18n: opts.skipI18n
   });
 });
+program.command("move").description(
+  "Copy a composed component and its related files (controller, i18n) into another repository"
+).argument(
+  "<components...>",
+  "component name(s), slug(s), or path(s) like labeled-select or components/ui"
+).option("-t, --to <path>", "destination repository path", process.cwd()).option(
+  "-f, --from <path>",
+  "source boilerplate repository (optional; the published package uses its bundled registry)"
+).option("-o, --overwrite", "overwrite files that already exist", false).action(async (components, opts) => {
+  await runMove(components, {
+    to: opts.to,
+    from: opts.from,
+    overwrite: opts.overwrite
+  });
+});
+var create = program.command("create").description(
+  "Install a feature that already exists in the boilerplate into a target project"
+).addHelpText(
+  "after",
+  `
+The boilerplate is the single source of truth for which features exist. This
+does not generate arbitrary/new features \u2014 it installs an existing, registered
+boilerplate feature's real files into a target project, in the implementation
+that matches the target project's own framework.
+
+  Boilerplate -> Feature Registry -> Feature -> Framework Implementation -> Target Project
+
+See \`composed-cli create feature --help\` for the feature installer.`
+);
+create.command("feature").description(
+  "Install an existing boilerplate feature (route, screen, API layer, translations) into a target project, using the implementation registered for that project's detected framework."
+).argument("<name>", "registered feature name, e.g. login, dashboard, about, contact").option("-c, --cwd <path>", "target project directory", process.cwd()).option("--protected", "require/assert the protected-route implementation").option("--public", "require/assert the public-route implementation").option("-o, --overwrite", "overwrite files that already exist", false).addHelpText(
+  "after",
+  `
+The target project's framework is detected automatically (package.json
+dependencies, then project structure) \u2014 it does not need to be a copy of this
+boilerplate. Only frameworks with a registered implementation for the
+requested feature are supported; run the command to see the registry's error
+message list available features or supported frameworks.
+
+--protected / --public are validated against the resolved implementation's
+own route scope (e.g. dashboard is always protected, about is always public)
+rather than choosing it \u2014 pass one only to assert the scope you expect;
+omit both to just install whatever the registry defines.
+
+Examples:
+  $ composed-cli create feature login
+  $ composed-cli create feature dashboard
+  $ composed-cli create feature login --cwd ./next-app
+  $ composed-cli create feature dashboard --cwd ./tanstack-app
+  $ composed-cli create feature login --overwrite
+
+Behavior:
+  - Unknown feature name -> rejected, lists available features.
+   - Feature exists but no implementation for the detected framework -> rejected, lists supported frameworks.
+   - Next.js targets install App Router pages from cli/templates/nextjs/ and rewrite Paraglide to @/lib/composed-strings.
+  - Every target file is checked for conflicts before anything is written; existing files are reported and left untouched unless --overwrite is passed.
+  - Files are copied byte-for-byte from the boilerplate's real source tree \u2014 nothing is templated or invented.
+  - Translation keys are merged into the target's messages/<locale>/*.json when that folder exists; skipped otherwise.`
+).action(async (name, opts) => {
+  await runCreateFeature(name, {
+    cwd: opts.cwd,
+    protected: opts.protected ?? false,
+    public: opts.public ?? false,
+    overwrite: opts.overwrite
+  });
+});
 program.parseAsync(process.argv);