loor-cli 0.1.0

package/dist/cli-PUXM5F6I.js

@@ -0,0 +1,1083 @@
+import {
+  PackageRegistry,
+  addAnnotatedBlock,
+  detectProject,
+  ensureCache,
+  getAppsDir,
+  getPackagesDir,
+  getRegistryDir,
+  mergeDependencies,
+  readConfig,
+  removeBetweenAnnotations,
+  removeDependencies,
+  replaceInFile,
+  writeConfig
+} from "./chunk-E6WOLYO3.js";
+import {
+  enableDebug,
+  log
+} from "./chunk-AUVNDYJL.js";
+
+// src/cli.ts
+import { Command as Command7 } from "commander";
+
+// src/commands/init.ts
+import path4 from "path";
+import fs4 from "fs-extra";
+import * as p2 from "@clack/prompts";
+import { Command } from "commander";
+
+// src/registry/dependencyResolver.ts
+function resolveDependencies(packageNames, registry) {
+  const resolved = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const order = [];
+  function visit(name) {
+    if (resolved.has(name)) return;
+    if (visiting.has(name)) {
+      throw new Error(`Circular dependency detected: ${name}`);
+    }
+    const manifest = registry.get(name);
+    if (!manifest) {
+      throw new Error(`Package not found: ${name}`);
+    }
+    visiting.add(name);
+    for (const dep of manifest.requires) {
+      visit(dep);
+    }
+    visiting.delete(name);
+    resolved.add(name);
+    order.push(name);
+  }
+  for (const name of packageNames) {
+    visit(name);
+  }
+  return order;
+}
+function resolveWithTransitiveDeps(selected, registry) {
+  const allDeps = /* @__PURE__ */ new Set();
+  function collectDeps(name) {
+    if (allDeps.has(name)) return;
+    allDeps.add(name);
+    const manifest = registry.get(name);
+    if (!manifest) return;
+    for (const dep of manifest.requires) {
+      collectDeps(dep);
+    }
+  }
+  for (const name of selected) {
+    collectDeps(name);
+  }
+  return resolveDependencies(Array.from(allDeps), registry);
+}
+
+// src/generators/projectGenerator.ts
+import path from "path";
+import fs from "fs-extra";
+
+// src/generators/mcpConfigGenerator.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function generateMcpConfig(projectDir) {
+  try {
+    await execFileAsync("claude", [
+      "mcp",
+      "add",
+      "--transport",
+      "stdio",
+      "--scope",
+      "project",
+      "loor",
+      "--",
+      "npx",
+      "loor",
+      "--mcp"
+    ], { cwd: projectDir });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("ENOENT")) {
+      log.warn("Claude Code CLI not found. Install it to enable MCP integration.");
+      log.dim("  npm install -g @anthropic-ai/claude-code");
+    } else {
+      log.warn(`Could not register MCP server: ${msg}`);
+    }
+  }
+}
+
+// src/generators/projectGenerator.ts
+async function generateProject(projectDir, projectName) {
+  const registryDir = await getRegistryDir();
+  log.step(`Creating project directory: ${projectName}`);
+  await fs.ensureDir(projectDir);
+  await fs.ensureDir(path.join(projectDir, "apps"));
+  await fs.ensureDir(path.join(projectDir, "packages"));
+  const filesToCopy = [
+    "turbo.json",
+    "pnpm-workspace.yaml",
+    "tsconfig.json",
+    "eslint.config.mjs",
+    ".env.example"
+  ];
+  for (const file of filesToCopy) {
+    const src = path.join(registryDir, file);
+    if (await fs.pathExists(src)) {
+      await fs.copy(src, path.join(projectDir, file));
+    }
+  }
+  const gitignoreSrc = path.join(registryDir, ".gitignore");
+  if (await fs.pathExists(gitignoreSrc)) {
+    await fs.copy(gitignoreSrc, path.join(projectDir, ".gitignore"));
+  }
+  const pkg = {
+    name: projectName,
+    version: "0.0.1",
+    private: true,
+    scripts: {
+      build: "turbo build",
+      dev: "turbo dev",
+      lint: "turbo lint",
+      format: 'prettier --write "**/*.{ts,tsx,md}"'
+    },
+    devDependencies: {
+      "@workspace/eslintConfig": "workspace:*",
+      "@workspace/typescriptConfig": "workspace:*",
+      prettier: "^3.6.2",
+      turbo: "^2.5.5",
+      typescript: "5.7.3"
+    },
+    packageManager: "pnpm@10.4.1",
+    engines: { node: ">=20" }
+  };
+  await fs.writeJson(path.join(projectDir, "package.json"), pkg, { spaces: 2 });
+  await generateMcpConfig(projectDir);
+  log.success("Project skeleton created");
+}
+
+// src/generators/appGenerator.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+async function generateApp(projectDir, appType, appName, projectName) {
+  const appsDir = await getAppsDir();
+  const sourceDir = path2.join(appsDir, appType);
+  const destDir = path2.join(projectDir, "apps", appName);
+  if (await fs2.pathExists(destDir)) {
+    throw new Error(`App directory already exists: apps/${appName}`);
+  }
+  log.step(`Generating ${appType} app: apps/${appName}`);
+  await fs2.copy(sourceDir, destDir, {
+    filter: (src) => {
+      const rel = path2.relative(sourceDir, src);
+      if (rel === "") return true;
+      if (rel.startsWith("node_modules") || rel.startsWith("dist") || rel.startsWith(".turbo")) return false;
+      return true;
+    }
+  });
+  await replaceInFile(
+    path2.join(destDir, "package.json"),
+    `@loor/${appType}`,
+    `@${projectName}/${appName}`
+  );
+  await replaceInFile(
+    path2.join(destDir, "package.json"),
+    "@loor/",
+    `@${projectName}/`
+  );
+  const authClientPath = path2.join(destDir, "src", "auth", "client.ts");
+  if (await fs2.pathExists(authClientPath)) {
+    await replaceInFile(authClientPath, "keyPrefix: 'loor.'", `keyPrefix: '${projectName}.'`);
+  }
+  log.success(`App created: apps/${appName}`);
+}
+
+// src/generators/packageGenerator.ts
+import path3 from "path";
+import fs3 from "fs-extra";
+async function removePackageArtifacts(projectDir, manifest) {
+  const appsDir = path3.join(projectDir, "apps");
+  if (await fs3.pathExists(appsDir)) {
+    const apps = await fs3.readdir(appsDir, { withFileTypes: true });
+    for (const app of apps) {
+      if (!app.isDirectory()) continue;
+      if (manifest.apiInfra) {
+        for (const file of manifest.apiInfra) {
+          const filePath = path3.join(appsDir, app.name, file.path);
+          if (await fs3.pathExists(filePath)) {
+            await fs3.remove(filePath);
+          }
+        }
+      }
+      if (manifest.clientSetup) {
+        for (const file of manifest.clientSetup) {
+          const filePath = path3.join(appsDir, app.name, file.path);
+          if (await fs3.pathExists(filePath)) {
+            await fs3.remove(filePath);
+          }
+        }
+      }
+      const appPkgJsonPath = path3.join(appsDir, app.name, "package.json");
+      if (await fs3.pathExists(appPkgJsonPath)) {
+        const depsToRemove = [`@workspace/${manifest.name}`];
+        if (manifest.appDependencies?.api) {
+          depsToRemove.push(...Object.keys(manifest.appDependencies.api));
+        }
+        if (manifest.appDependencies?.client) {
+          depsToRemove.push(...Object.keys(manifest.appDependencies.client));
+        }
+        await removeDependencies(appPkgJsonPath, depsToRemove);
+      }
+      const configPath = path3.join(appsDir, app.name, "src", "config", "index.ts");
+      await removeBetweenAnnotations(configPath, manifest.name);
+    }
+  }
+  const envPath = path3.join(projectDir, ".env.example");
+  await removeBetweenAnnotations(envPath, manifest.name);
+  const pkgDir = path3.join(projectDir, "packages", manifest.name);
+  if (await fs3.pathExists(pkgDir)) {
+    await fs3.remove(pkgDir);
+  }
+  log.dim(`  - Removed: ${manifest.name}`);
+}
+async function addPackage(projectDir, manifest) {
+  const srcPackagesDir = await getPackagesDir();
+  const srcPackageDir = path3.join(srcPackagesDir, manifest.name);
+  const destPackageDir = path3.join(projectDir, "packages", manifest.name);
+  if (!await fs3.pathExists(destPackageDir)) {
+    log.step(`Adding package: ${manifest.name}`);
+    await fs3.copy(srcPackageDir, destPackageDir, {
+      filter: (src) => {
+        const rel = path3.relative(srcPackageDir, src);
+        if (rel === "") return true;
+        if (rel.startsWith("node_modules") || rel.startsWith("dist")) return false;
+        if (rel === "loor.json") return false;
+        return true;
+      }
+    });
+  }
+  const referenceAppsDir = await getAppsDir();
+  const appsDir = path3.join(projectDir, "apps");
+  if (await fs3.pathExists(appsDir)) {
+    const apps = await fs3.readdir(appsDir, { withFileTypes: true });
+    for (const app of apps) {
+      if (!app.isDirectory()) continue;
+      const appPkgJsonPath = path3.join(appsDir, app.name, "package.json");
+      if (!await fs3.pathExists(appPkgJsonPath)) continue;
+      const appPkg = await fs3.readJson(appPkgJsonPath);
+      const isApi = appPkg.dependencies?.express || appPkg.dependencies?.mongoose;
+      const isClient = appPkg.dependencies?.react;
+      await mergeDependencies(appPkgJsonPath, {
+        [`@workspace/${manifest.name}`]: "workspace:*"
+      });
+      if (manifest.appDependencies) {
+        if (isApi && manifest.appDependencies.api) {
+          await mergeDependencies(appPkgJsonPath, manifest.appDependencies.api);
+        }
+        if (isClient && manifest.appDependencies.client) {
+          await mergeDependencies(appPkgJsonPath, manifest.appDependencies.client);
+        }
+      }
+      if (isApi && manifest.apiInfra) {
+        for (const file of manifest.apiInfra) {
+          const destPath = path3.join(appsDir, app.name, file.path);
+          if (await fs3.pathExists(destPath)) continue;
+          const srcPath = path3.join(referenceAppsDir, "api", file.path);
+          if (await fs3.pathExists(srcPath)) {
+            await fs3.ensureDir(path3.dirname(destPath));
+            await fs3.copy(srcPath, destPath);
+            log.dim(`  + ${file.path} (${file.description})`);
+          }
+        }
+      }
+      if (isClient && manifest.clientSetup) {
+        for (const file of manifest.clientSetup) {
+          const destPath = path3.join(appsDir, app.name, file.path);
+          if (await fs3.pathExists(destPath)) continue;
+          const srcPath = path3.join(referenceAppsDir, "web-client", file.path);
+          if (await fs3.pathExists(srcPath)) {
+            await fs3.ensureDir(path3.dirname(destPath));
+            await fs3.copy(srcPath, destPath);
+            log.dim(`  + ${file.path} (${file.description})`);
+          }
+        }
+      }
+    }
+  }
+  if (manifest.configKeys) {
+    await addConfigBlock(projectDir, manifest);
+  }
+  if (manifest.envVars) {
+    await addEnvBlock(projectDir, manifest);
+  }
+  log.success(`Package ready: ${manifest.name}`);
+}
+async function addConfigBlock(projectDir, manifest) {
+  if (!manifest.configKeys) return;
+  const appsDir = path3.join(projectDir, "apps");
+  if (!await fs3.pathExists(appsDir)) return;
+  const apps = await fs3.readdir(appsDir, { withFileTypes: true });
+  for (const app of apps) {
+    if (!app.isDirectory()) continue;
+    const configPath = path3.join(appsDir, app.name, "src", "config", "index.ts");
+    if (!await fs3.pathExists(configPath)) continue;
+    const block = buildConfigBlock(manifest.configKeys);
+    await addAnnotatedBlock(configPath, manifest.name, block, "//");
+  }
+}
+async function addEnvBlock(projectDir, manifest) {
+  if (!manifest.envVars) return;
+  const envPath = path3.join(projectDir, ".env.example");
+  if (!await fs3.pathExists(envPath)) return;
+  const lines = [];
+  for (const envVar of manifest.envVars) {
+    lines.push(`${envVar.key}=${envVar.defaultValue}`);
+  }
+  await addAnnotatedBlock(envPath, manifest.name, lines.join("\n"), "#");
+}
+function buildConfigBlock(keys) {
+  const tree = {};
+  for (const key of keys) {
+    const parts = key.path.split(".");
+    let current = tree;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!current[parts[i]] || typeof current[parts[i]] !== "object") {
+        current[parts[i]] = {};
+      }
+      current = current[parts[i]];
+    }
+    current[parts[parts.length - 1]] = key.expression;
+  }
+  return stringifyConfigTree(tree, 1);
+}
+function stringifyConfigTree(tree, depth) {
+  const indent = "  ".repeat(depth);
+  const lines = [];
+  for (const [key, value] of Object.entries(tree)) {
+    if (typeof value === "string") {
+      lines.push(`${indent}${key}: ${value},`);
+    } else {
+      lines.push(`${indent}${key}: {`);
+      lines.push(stringifyConfigTree(value, depth + 1));
+      lines.push(`${indent}},`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/utils/prompt.ts
+import * as p from "@clack/prompts";
+async function promptProjectName(defaultName) {
+  const name = await p.text({
+    message: "Project name:",
+    placeholder: defaultName || "my-app",
+    validate: (value) => {
+      if (!value.trim()) return "Project name is required";
+      if (!/^[a-z0-9-]+$/.test(value)) return "Use lowercase letters, numbers, and hyphens only";
+      return void 0;
+    }
+  });
+  if (p.isCancel(name)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return name;
+}
+async function promptAppTypes() {
+  const result = await p.multiselect({
+    message: "Which app types do you want to create?",
+    options: [
+      { value: "api", label: "API (Express + MongoDB)", hint: "REST API server" },
+      { value: "web-client", label: "Web Client (React + Vite)", hint: "Admin panel" }
+    ],
+    required: true
+  });
+  if (p.isCancel(result)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return result;
+}
+async function promptPackages(packages, appTypes) {
+  const compatTypes = appTypes.map((t) => t === "web-client" ? "client" : t);
+  const compatible = packages.filter(
+    (pkg) => pkg.compatibility.some((c) => compatTypes.includes(c))
+  );
+  if (compatible.length === 0) return [];
+  const grouped = {
+    core: compatible.filter((p4) => p4.category === "core"),
+    server: compatible.filter((p4) => p4.category === "server"),
+    client: compatible.filter((p4) => p4.category === "client"),
+    config: compatible.filter((p4) => p4.category === "config")
+  };
+  const options = [
+    ...grouped.core.map((p4) => ({ value: p4.name, label: `[core] ${p4.name}`, hint: p4.description })),
+    ...grouped.server.map((p4) => ({ value: p4.name, label: `[server] ${p4.name}`, hint: p4.description })),
+    ...grouped.client.map((p4) => ({ value: p4.name, label: `[client] ${p4.name}`, hint: p4.description })),
+    ...grouped.config.map((p4) => ({ value: p4.name, label: `[config] ${p4.name}`, hint: p4.description }))
+  ];
+  const result = await p.multiselect({
+    message: "Select packages to include:",
+    options,
+    required: false
+  });
+  if (p.isCancel(result)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return result;
+}
+async function promptAppName(appType) {
+  const defaultName = appType === "api" ? "api" : "admin";
+  const name = await p.text({
+    message: `Name for the ${appType} app:`,
+    placeholder: defaultName,
+    initialValue: defaultName,
+    validate: (value) => {
+      if (!value.trim()) return "App name is required";
+      if (!/^[a-z0-9-]+$/.test(value)) return "Use lowercase letters, numbers, and hyphens only";
+      return void 0;
+    }
+  });
+  if (p.isCancel(name)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return name;
+}
+
+// src/commands/init.ts
+var REQUIRED_PACKAGES = {
+  api: ["auth", "base", "expressRouteKit", "logger", "eslintConfig", "typescriptConfig"],
+  "web-client": ["auth", "base", "storage", "ui", "i18n", "routerProvider", "commandMenu", "apiClient", "eslintConfig", "typescriptConfig"]
+};
+var VALID_APP_TYPES = ["api", "web-client"];
+function parseAppsFlag(raw) {
+  const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  const apps = [];
+  for (const part of parts) {
+    const [typePart, namePart] = part.split(":");
+    const type = typePart.trim();
+    if (!VALID_APP_TYPES.includes(type)) {
+      log.error(`Invalid app type: "${type}". Must be one of: ${VALID_APP_TYPES.join(", ")}`);
+      process.exit(1);
+    }
+    const appType = type;
+    const defaultName = appType === "api" ? "api" : "admin";
+    const name = namePart?.trim() || defaultName;
+    if (!/^[a-z0-9-]+$/.test(name)) {
+      log.error(`Invalid app name: "${name}". Use lowercase letters, numbers, and hyphens only.`);
+      process.exit(1);
+    }
+    apps.push({ type: appType, name });
+  }
+  if (apps.length === 0) {
+    log.error("--apps requires at least one app type.");
+    process.exit(1);
+  }
+  return apps;
+}
+function parsePackagesFlag(raw) {
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+var initCommand = new Command("init").description("Create a new loor monorepo project").argument("[name]", "Project name (lowercase, hyphens allowed)").option("--apps <apps>", "App types with optional names (e.g., api:backend,web-client:dashboard)").option("--packages <packages>", "Optional packages to include (comma-separated)").option("--no-packages", "Skip optional package selection (install only required packages)").addHelpText("after", `
+Examples:
+  $ loor init my-saas                            # Interactive mode
+  $ loor init my-saas --apps api,web-client      # With default app names
+  $ loor init my-saas --apps api:backend,web-client:admin --packages mediaKit,mailer
+  $ loor init my-saas --apps api --no-packages   # API only, no optional packages
+`).action(async (name, opts) => {
+  await ensureCache();
+  p2.intro("Create a new loor project");
+  const projectName = name || await promptProjectName();
+  const projectDir = path4.resolve(process.cwd(), projectName);
+  if (await fs4.pathExists(projectDir)) {
+    log.error(`Directory already exists: ${projectName}`);
+    process.exit(1);
+  }
+  let apps;
+  if (opts.apps) {
+    apps = parseAppsFlag(opts.apps);
+    log.info(`Apps: ${apps.map((a) => `${a.type}:${a.name}`).join(", ")}`);
+  } else {
+    const appTypes2 = await promptAppTypes();
+    apps = [];
+    for (const appType of appTypes2) {
+      const appName = await promptAppName(appType);
+      apps.push({ type: appType, name: appName });
+    }
+  }
+  const appTypes = apps.map((a) => a.type);
+  const requiredSet = /* @__PURE__ */ new Set();
+  for (const appType of appTypes) {
+    for (const pkg of REQUIRED_PACKAGES[appType]) {
+      requiredSet.add(pkg);
+    }
+  }
+  const registry = new PackageRegistry(await getPackagesDir());
+  await registry.load();
+  const allPackages = registry.getAll();
+  let selectedPackageNames;
+  if (opts.packages === false) {
+    selectedPackageNames = [];
+    log.info("Skipping optional packages (--no-packages)");
+  } else if (typeof opts.packages === "string") {
+    selectedPackageNames = parsePackagesFlag(opts.packages);
+    for (const pkgName of selectedPackageNames) {
+      if (!registry.get(pkgName)) {
+        log.error(`Package not found: "${pkgName}". Run "loor list" to see available packages.`);
+        process.exit(1);
+      }
+    }
+    log.info(`Selected packages: ${selectedPackageNames.join(", ")}`);
+  } else {
+    const optionalPackages = allPackages.filter((pkg) => !requiredSet.has(pkg.name));
+    selectedPackageNames = await promptPackages(optionalPackages, appTypes);
+  }
+  const allSelected = [...requiredSet, ...selectedPackageNames];
+  const resolvedPackages = resolveWithTransitiveDeps(allSelected, registry);
+  const userPicked = new Set(selectedPackageNames);
+  const autoAdded = resolvedPackages.filter((n) => !userPicked.has(n) && !requiredSet.has(n));
+  if (autoAdded.length > 0) {
+    log.info(`Auto-adding transitive dependencies: ${autoAdded.join(", ")}`);
+  }
+  log.info(`Required by apps: ${[...requiredSet].join(", ")}`);
+  const resolvedSet = new Set(resolvedPackages);
+  const spinner3 = p2.spinner();
+  spinner3.start("Creating project skeleton");
+  await generateProject(projectDir, projectName);
+  spinner3.stop("Project skeleton created");
+  for (const app of apps) {
+    spinner3.start(`Generating ${app.type} app: ${app.name}`);
+    await generateApp(projectDir, app.type, app.name, projectName);
+    spinner3.stop(`App created: ${app.name}`);
+  }
+  spinner3.start("Copying packages");
+  const srcPackagesDir = await getPackagesDir();
+  const destPackagesDir = path4.join(projectDir, "packages");
+  const allPkgNames = allPackages.map((p4) => p4.name);
+  for (const pkgName of allPkgNames) {
+    const srcDir = path4.join(srcPackagesDir, pkgName);
+    const destDir = path4.join(destPackagesDir, pkgName);
+    if (await fs4.pathExists(srcDir)) {
+      await fs4.copy(srcDir, destDir, {
+        filter: (src) => {
+          const rel = path4.relative(srcDir, src);
+          if (rel === "") return true;
+          if (rel.startsWith("node_modules") || rel.startsWith("dist")) return false;
+          if (rel === "loor.json") return false;
+          return true;
+        }
+      });
+    }
+  }
+  spinner3.stop("Packages copied");
+  const unselected = allPkgNames.filter((n) => !resolvedSet.has(n));
+  if (unselected.length > 0) {
+    spinner3.start("Removing unselected packages");
+    for (const pkgName of unselected) {
+      const manifest = registry.get(pkgName);
+      if (!manifest) continue;
+      await removePackageArtifacts(projectDir, manifest);
+    }
+    spinner3.stop("Cleaned up unselected packages");
+  }
+  spinner3.start("Applying project name");
+  await applyProjectName(projectDir, projectName);
+  spinner3.stop("Project name applied");
+  p2.outro("Project created successfully!");
+  console.log("");
+  log.info("Next steps:");
+  log.dim(`  cd ${projectName}`);
+  log.dim("  pnpm install");
+  log.dim("  pnpm dev");
+});
+async function applyProjectName(projectDir, projectName) {
+  const appsDir = path4.join(projectDir, "apps");
+  if (await fs4.pathExists(appsDir)) {
+    const apps = await fs4.readdir(appsDir, { withFileTypes: true });
+    for (const app of apps) {
+      if (!app.isDirectory()) continue;
+      const pkgJsonPath = path4.join(appsDir, app.name, "package.json");
+      await replaceInFile(pkgJsonPath, "@loor/", `@${projectName}/`);
+      const authClientPath = path4.join(appsDir, app.name, "src", "auth", "client.ts");
+      await replaceInFile(authClientPath, "keyPrefix: 'loor.'", `keyPrefix: '${projectName}.'`);
+    }
+  }
+}
+
+// src/commands/add.ts
+import path5 from "path";
+import fs5 from "fs-extra";
+import * as p3 from "@clack/prompts";
+import { Command as Command2 } from "commander";
+var REQUIRED_PACKAGES2 = {
+  api: ["auth", "base", "expressRouteKit", "logger", "eslintConfig", "typescriptConfig"],
+  "web-client": ["auth", "base", "storage", "ui", "i18n", "routerProvider", "commandMenu", "apiClient", "eslintConfig", "typescriptConfig"]
+};
+var addApp = new Command2("app").description("Add a new app to the project").argument("<type>", "App type: api or web-client").argument("[name]", "Custom app name (e.g. backend, dashboard)").addHelpText("after", `
+Examples:
+  $ loor add app api              # Prompts for name if "api" already exists
+  $ loor add app api backend      # Creates apps/backend (api type)
+  $ loor add app web-client       # Prompts for name if "admin" already exists
+  $ loor add app web-client dash  # Creates apps/dash (web-client type)
+`).action(async (type, name) => {
+  await ensureCache();
+  if (type !== "api" && type !== "web-client") {
+    log.error(`Invalid app type: "${type}". Must be "api" or "web-client".`);
+    process.exit(1);
+  }
+  const projectDir = process.cwd();
+  if (!await detectProject(projectDir)) {
+    log.error("Not a loor project. Run this command from the project root.");
+    process.exit(1);
+  }
+  if (name && !/^[a-z0-9-]+$/.test(name)) {
+    log.error("App name must be lowercase letters, numbers, and hyphens only.");
+    process.exit(1);
+  }
+  const appType = type;
+  let appName = name || (appType === "api" ? "api" : "admin");
+  const destDir = path5.join(projectDir, "apps", appName);
+  if (!name && await fs5.pathExists(destDir)) {
+    log.warn(`apps/${appName} already exists.`);
+    const customName = await p3.text({
+      message: `Enter a name for the new ${appType} app:`,
+      placeholder: appType === "api" ? "backend" : "dashboard",
+      validate: (value) => {
+        if (!value.trim()) return "App name is required";
+        if (!/^[a-z0-9-]+$/.test(value)) return "Use lowercase letters, numbers, and hyphens only";
+        return void 0;
+      }
+    });
+    if (p3.isCancel(customName)) {
+      p3.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    appName = customName;
+    if (await fs5.pathExists(path5.join(projectDir, "apps", appName))) {
+      log.error(`apps/${appName} already exists. Choose a different name.`);
+      process.exit(1);
+    }
+  }
+  if (name && await fs5.pathExists(path5.join(projectDir, "apps", appName))) {
+    log.error(`apps/${appName} already exists. Choose a different name.`);
+    process.exit(1);
+  }
+  const rootPkg = await fs5.readJson(path5.join(projectDir, "package.json"));
+  const projectName = rootPkg.name || "app";
+  p3.intro(`Adding ${appType} app: ${appName}`);
+  const registry = new PackageRegistry(await getPackagesDir());
+  await registry.load();
+  const spinner3 = p3.spinner();
+  spinner3.start(`Generating ${appType} app`);
+  await generateApp(projectDir, appType, appName, projectName);
+  spinner3.stop(`App created: ${appName}`);
+  const required = REQUIRED_PACKAGES2[appType];
+  const resolved = resolveWithTransitiveDeps(required, registry);
+  const packagesDir = path5.join(projectDir, "packages");
+  const missing = [];
+  for (const pkgName of resolved) {
+    if (!await fs5.pathExists(path5.join(packagesDir, pkgName))) {
+      missing.push(pkgName);
+    }
+  }
+  if (missing.length > 0) {
+    log.info(`Installing required packages: ${missing.join(", ")}`);
+    for (const pkgName of missing) {
+      const manifest = registry.get(pkgName);
+      if (!manifest) continue;
+      spinner3.start(`Adding required package: ${pkgName}`);
+      await addPackage(projectDir, manifest);
+      spinner3.stop(`Package ready: ${pkgName}`);
+    }
+  }
+  const existingPkgs = /* @__PURE__ */ new Set();
+  if (await fs5.pathExists(packagesDir)) {
+    const entries = await fs5.readdir(packagesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) existingPkgs.add(entry.name);
+    }
+  }
+  const allPackages = registry.getAll();
+  for (const pkg of allPackages) {
+    if (!existingPkgs.has(pkg.name)) {
+      await removePackageArtifacts(projectDir, pkg);
+    }
+  }
+  p3.outro("App added successfully!");
+  log.dim("  Run pnpm install to update dependencies");
+});
+var addPackageCmd = new Command2("package").description("Add a package to the project").argument("<name>", 'Package name (run "loor list" to see available)').addHelpText("after", `
+Examples:
+  $ loor add package mediaKit
+  $ loor add package mailer
+`).action(async (name) => {
+  await ensureCache();
+  const projectDir = process.cwd();
+  if (!await detectProject(projectDir)) {
+    log.error("Not a loor project. Run this command from the project root.");
+    process.exit(1);
+  }
+  const registry = new PackageRegistry(await getPackagesDir());
+  await registry.load();
+  const manifest = registry.get(name);
+  if (!manifest) {
+    log.error(`Package not found: ${name}`);
+    log.dim('Run "loor list" to see available packages.');
+    process.exit(1);
+  }
+  const resolved = resolveWithTransitiveDeps([name], registry);
+  const toInstall = [];
+  for (const pkgName of resolved) {
+    const pkgDir = path5.join(projectDir, "packages", pkgName);
+    if (!await fs5.pathExists(pkgDir)) {
+      toInstall.push(pkgName);
+    }
+  }
+  if (toInstall.length === 0) {
+    log.info(`Package "${name}" is already installed.`);
+    return;
+  }
+  p3.intro(`Adding package: ${name}`);
+  if (toInstall.length > 1) {
+    const deps = toInstall.filter((n) => n !== name);
+    if (deps.length > 0) {
+      log.info(`Also adding dependencies: ${deps.join(", ")}`);
+    }
+  }
+  const spinner3 = p3.spinner();
+  for (const pkgName of toInstall) {
+    const pkgManifest = registry.get(pkgName);
+    spinner3.start(`Adding ${pkgName}`);
+    await addPackage(projectDir, pkgManifest);
+    spinner3.stop(`Package ready: ${pkgName}`);
+  }
+  p3.outro("Package added successfully!");
+  log.dim("  Run pnpm install to update dependencies");
+});
+var addCommand = new Command2("add").description("Add an app or package to the project").addHelpText("after", `
+Examples:
+  $ loor add app api backend
+  $ loor add app web-client dashboard
+  $ loor add package mediaKit
+`).addCommand(addApp).addCommand(addPackageCmd);
+
+// src/commands/list.ts
+import { Command as Command3 } from "commander";
+import chalk from "chalk";
+var listCommand = new Command3("list").description("List all available packages").action(async () => {
+  await ensureCache();
+  const registry = new PackageRegistry(await getPackagesDir());
+  await registry.load();
+  const categories = ["core", "server", "client", "config"];
+  console.log("");
+  console.log(chalk.bold("Available packages:"));
+  console.log("");
+  for (const category of categories) {
+    const packages = registry.getByCategory(category);
+    if (packages.length === 0) continue;
+    console.log(chalk.cyan.bold(`  ${category.toUpperCase()}`));
+    for (const pkg of packages) {
+      const compat = pkg.compatibility.join(", ");
+      const deps = pkg.requires.length > 0 ? chalk.dim(` (requires: ${pkg.requires.join(", ")})`) : "";
+      console.log(`    ${chalk.white(pkg.name.padEnd(20))} ${chalk.dim(pkg.description)}${deps}`);
+      console.log(`    ${"".padEnd(20)} ${chalk.dim(`compat: ${compat}`)}`);
+    }
+    console.log("");
+  }
+});
+
+// src/commands/update.ts
+import { Command as Command4 } from "commander";
+var updateCommand = new Command4("update").description("Update package registry from remote").action(async () => {
+  await ensureCache({ force: true });
+  log.success("Registry is up to date.");
+});
+
+// src/commands/ai.ts
+import { Command as Command5 } from "commander";
+
+// src/generators/claudeMdGenerator.ts
+import path6 from "path";
+import fs6 from "fs-extra";
+async function generateClaudeMd(projectDir, registry) {
+  const sections = [];
+  const projectName = await getProjectName(projectDir);
+  sections.push(`# ${projectName}`);
+  sections.push("");
+  sections.push("> Auto-generated by `loor ai init`. MCP server is auto-configured in `.mcp.json`.");
+  sections.push("");
+  const apps = await detectApps(projectDir);
+  if (apps.length > 0) {
+    sections.push("## Apps");
+    sections.push("");
+    for (const app of apps) {
+      sections.push(`- **${app.name}** (${app.type}) \u2014 \`${app.path}\``);
+    }
+    sections.push("");
+  }
+  const archSummary = await getArchitectureSummary(registry.getPackagesDir());
+  if (archSummary) {
+    sections.push("## Architecture");
+    sections.push("");
+    sections.push(archSummary);
+    sections.push("");
+  }
+  const installedPackages = await getInstalledPackages(projectDir, registry, apps);
+  if (installedPackages.length > 0) {
+    sections.push("## Installed Packages");
+    sections.push("");
+    for (const pkg of installedPackages) {
+      sections.push(`### ${pkg.name}`);
+      sections.push(`${pkg.description} | **${pkg.category}** | compat: ${pkg.compatibility.join(", ")}`);
+      if (pkg.ai?.patterns?.length) {
+        sections.push("");
+        sections.push("**DO:**");
+        for (const p4 of pkg.ai.patterns) {
+          sections.push(`- ${p4}`);
+        }
+      }
+      if (pkg.ai?.donts?.length) {
+        sections.push("");
+        sections.push("**DON'T:**");
+        for (const d of pkg.ai.donts) {
+          sections.push(`- ${d}`);
+        }
+      }
+      if (pkg.apiInfra?.length) {
+        sections.push("");
+        sections.push("**Infra files:**");
+        for (const infra of pkg.apiInfra) {
+          sections.push(`- \`${infra.path}\` \u2014 ${infra.description}`);
+        }
+      }
+      if (pkg.envVars?.length) {
+        const required = pkg.envVars.filter((e) => e.required);
+        if (required.length > 0) {
+          sections.push("");
+          sections.push("**Required env vars:** " + required.map((e) => `\`${e.key}\``).join(", "));
+        }
+      }
+      sections.push("");
+    }
+  }
+  sections.push("## Conventions");
+  sections.push("");
+  sections.push("- **Hexagonal Architecture:** Packages define ports (interfaces), apps implement adapters in `src/infra/`");
+  sections.push("- **Package exports:** `index.ts` = pure/universal, `server/index.ts` = Node.js only, `client/index.ts` = browser only");
+  sections.push("- **Routes:** Extend `RouteProvider`, place in `src/routes/<domain>/<action>/index.ts` for auto-discovery");
+  sections.push("- **Features:** Self-contained in `src/features/<name>/` with components, hooks, types, locales");
+  sections.push("- **No Buffer in packages:** Use `Uint8Array` for universal compatibility");
+  sections.push("");
+  for (const app of apps) {
+    const appFullPath = path6.join(projectDir, app.path);
+    const appContext = await getAppContext(app, appFullPath);
+    if (appContext) {
+      sections.push(appContext);
+    }
+  }
+  const content = sections.join("\n");
+  await fs6.writeFile(path6.join(projectDir, "CLAUDE.md"), content, "utf-8");
+}
+async function getProjectName(projectDir) {
+  const pkgJsonPath = path6.join(projectDir, "package.json");
+  if (await fs6.pathExists(pkgJsonPath)) {
+    const pkg = await fs6.readJson(pkgJsonPath);
+    if (pkg.name) return pkg.name;
+  }
+  return path6.basename(projectDir);
+}
+async function detectApps(projectDir) {
+  const appsDir = path6.join(projectDir, "apps");
+  if (!await fs6.pathExists(appsDir)) return [];
+  const entries = await fs6.readdir(appsDir, { withFileTypes: true });
+  const apps = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const appDir = path6.join(appsDir, entry.name);
+    const pkgJsonPath = path6.join(appDir, "package.json");
+    if (!await fs6.pathExists(pkgJsonPath)) continue;
+    const pkg = await fs6.readJson(pkgJsonPath);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const type = inferAppType(deps);
+    apps.push({
+      name: entry.name,
+      type,
+      path: `apps/${entry.name}`
+    });
+  }
+  return apps;
+}
+function inferAppType(deps) {
+  if (deps.express || deps.mongoose || deps.fastify) return "api";
+  if (deps.react || deps.vue || deps.svelte || deps["react-dom"]) return "client";
+  return "api";
+}
+async function getArchitectureSummary(packagesDir) {
+  const docsDir = path6.join(packagesDir, "..", "docs");
+  const standardPath = path6.join(docsDir, "PACKAGE_STANDARD.md");
+  if (await fs6.pathExists(standardPath)) {
+    const content = await fs6.readFile(standardPath, "utf-8");
+    const lines = content.split("\n");
+    const summary = lines.slice(0, 15).join("\n").trim();
+    if (summary) return summary;
+  }
+  return [
+    "Hexagonal Architecture (Ports & Adapters):",
+    "- Packages define abstract ports (interfaces) in `ports/` folder",
+    "- Apps implement adapters in `infra/` folder",
+    "- Factory functions accept ports as dependencies for DI"
+  ].join("\n");
+}
+async function getInstalledPackages(projectDir, registry, apps = []) {
+  const found = /* @__PURE__ */ new Set();
+  const pkgsDir = path6.join(projectDir, "packages");
+  if (await fs6.pathExists(pkgsDir)) {
+    const entries = await fs6.readdir(pkgsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === "cli") continue;
+      if (registry.get(entry.name)) found.add(entry.name);
+    }
+  }
+  for (const app of apps) {
+    const pkgJsonPath = path6.join(projectDir, app.path, "package.json");
+    if (!await fs6.pathExists(pkgJsonPath)) continue;
+    const pkg = await fs6.readJson(pkgJsonPath);
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    for (const dep of Object.keys(allDeps)) {
+      if (!dep.startsWith("@workspace/")) continue;
+      const pkgName = dep.replace("@workspace/", "");
+      if (registry.get(pkgName)) found.add(pkgName);
+    }
+  }
+  return Array.from(found).sort().map((name) => registry.get(name)).filter(Boolean);
+}
+async function getAppContext(app, appFullPath) {
+  const lines = [];
+  if (app.type === "api") {
+    const routesDir = path6.join(appFullPath, "src", "routes");
+    if (await fs6.pathExists(routesDir)) {
+      const routes = await scanDirs(routesDir, 2);
+      if (routes.length > 0) {
+        lines.push(`## ${app.name} \u2014 Routes`);
+        lines.push("");
+        for (const route of routes) {
+          lines.push(`- \`src/routes/${route}\``);
+        }
+        lines.push("");
+      }
+    }
+    const infraDir = path6.join(appFullPath, "src", "infra");
+    if (await fs6.pathExists(infraDir)) {
+      const infraFiles = await fs6.readdir(infraDir);
+      const tsFiles = infraFiles.filter((f) => f.endsWith(".ts"));
+      if (tsFiles.length > 0) {
+        lines.push(`## ${app.name} \u2014 Infrastructure`);
+        lines.push("");
+        for (const f of tsFiles) {
+          lines.push(`- \`src/infra/${f}\``);
+        }
+        lines.push("");
+      }
+    }
+  } else {
+    const featuresDir = path6.join(appFullPath, "src", "features");
+    if (await fs6.pathExists(featuresDir)) {
+      const features = await fs6.readdir(featuresDir, { withFileTypes: true });
+      const featureNames = features.filter((f) => f.isDirectory()).map((f) => f.name);
+      if (featureNames.length > 0) {
+        lines.push(`## ${app.name} \u2014 Features`);
+        lines.push("");
+        for (const f of featureNames) {
+          lines.push(`- \`src/features/${f}\``);
+        }
+        lines.push("");
+      }
+    }
+  }
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+async function scanDirs(dir, depth, prefix = "") {
+  if (depth <= 0) return [prefix].filter(Boolean);
+  const entries = await fs6.readdir(dir, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const childPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    const children = await scanDirs(path6.join(dir, entry.name), depth - 1, childPath);
+    results.push(...children);
+  }
+  return results;
+}
+
+// src/commands/ai.ts
+var aiCommand = new Command5("ai").description("AI context tools");
+aiCommand.addCommand(
+  new Command5("init").description("Generate CLAUDE.md with project-specific AI context").action(async () => {
+    await ensureCache();
+    const registry = new PackageRegistry(await getPackagesDir());
+    await registry.load();
+    const projectDir = process.cwd();
+    await generateClaudeMd(projectDir, registry);
+    await generateMcpConfig(projectDir);
+    log.success("CLAUDE.md generated successfully.");
+    log.success(".mcp.json generated successfully.");
+  })
+);
+
+// src/commands/config.ts
+import path7 from "path";
+import fs7 from "fs-extra";
+import { Command as Command6 } from "commander";
+var configCommand = new Command6("config").description("Configure loor CLI source (local or remote)").option("--local [path]", "Use local repo as scaffold source (defaults to cwd)").option("--remote", "Use remote registry (production)").action(async (opts) => {
+  if (!opts.local && !opts.remote) {
+    const config = await readConfig();
+    if (process.env.LOOR_LOCAL) {
+      log.warn(`LOOR_LOCAL env var is set \u2014 overrides config to: ${process.env.LOOR_LOCAL}`);
+    }
+    log.info(`source: ${config.source}`);
+    if (config.source === "local" && config.localPath) {
+      log.info(`path:   ${config.localPath}`);
+    }
+    return;
+  }
+  if (opts.remote) {
+    await writeConfig({ source: "remote" });
+    log.success("Switched to remote mode.");
+    return;
+  }
+  if (opts.local !== void 0) {
+    const rawPath = typeof opts.local === "string" ? opts.local : ".";
+    const absPath = path7.resolve(process.cwd(), rawPath);
+    const hasApps = await fs7.pathExists(path7.join(absPath, "apps"));
+    const hasPackages = await fs7.pathExists(path7.join(absPath, "packages"));
+    if (!hasApps || !hasPackages) {
+      log.error(`Invalid loor repo: ${absPath}`);
+      log.dim("  Expected apps/ and packages/ directories.");
+      process.exit(1);
+    }
+    await writeConfig({ source: "local", localPath: absPath });
+    log.success(`Switched to local mode: ${absPath}`);
+  }
+});
+
+// src/cli.ts
+var cli = new Command7().name("loor").description("Scaffold and manage loor monorepo projects").version("0.1.0").option("--debug", "Enable debug mode with detailed error output").addHelpText("after", `
+Getting started:
+  $ loor init my-project    Create a new project
+  $ loor add app api        Add an app to existing project
+  $ loor add package mailer Add a package to existing project
+  $ loor list               List available packages
+`).hook("preAction", (thisCommand) => {
+  const opts = thisCommand.optsWithGlobals();
+  if (opts.debug) enableDebug();
+});
+cli.addCommand(initCommand);
+cli.addCommand(addCommand);
+cli.addCommand(listCommand);
+cli.addCommand(updateCommand);
+cli.addCommand(aiCommand);
+cli.addCommand(configCommand);
+export {
+  cli
+};