@marwes-ui/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,843 @@
+import { parseArgs } from 'util';
+import { resolve, join } from 'path';
+import { spawn } from 'child_process';
+import { readFile, access, readdir, writeFile } from 'fs/promises';
+
+// src/index.ts
+var defaultCommandRunner = (command, options) => {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command.command, command.args, {
+      cwd: options.cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => resolve2(code ?? 1));
+  });
+};
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectPackageManager(cwd) {
+  if (await exists(join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (await exists(join(cwd, "bun.lockb")) || await exists(join(cwd, "bun.lock"))) {
+    return "bun";
+  }
+  if (await exists(join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (await exists(join(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  return "pnpm";
+}
+function installCommand(packageManager, packages) {
+  if (packageManager === "npm") {
+    return { command: "npm", args: ["install", ...packages] };
+  }
+  return { command: packageManager, args: ["add", ...packages] };
+}
+function runScriptCommand(packageManager, scriptName) {
+  if (packageManager === "npm" || packageManager === "pnpm" || packageManager === "bun") {
+    return { command: packageManager, args: ["run", scriptName] };
+  }
+  return { command: "yarn", args: [scriptName] };
+}
+function createViteCommand(packageManager, projectName, viteTemplate) {
+  if (packageManager === "pnpm") {
+    return {
+      command: "pnpm",
+      args: ["create", "vite@latest", projectName, "--", "--template", viteTemplate]
+    };
+  }
+  if (packageManager === "npm") {
+    return {
+      command: "npm",
+      args: ["create", "vite@latest", projectName, "--", "--template", viteTemplate]
+    };
+  }
+  if (packageManager === "bun") {
+    return {
+      command: "bun",
+      args: ["create", "vite", projectName, "--template", viteTemplate]
+    };
+  }
+  return {
+    command: "yarn",
+    args: ["create", "vite", projectName, "--template", viteTemplate]
+  };
+}
+function formatShellCommand(command) {
+  return [command.command, ...command.args].join(" ");
+}
+
+// src/recipes.ts
+var adapters = ["react", "vue", "svelte"];
+var packageManagers = ["pnpm", "npm", "yarn", "bun"];
+var marwesTemplates = ["react-ts", "vue-ts", "svelte-ts"];
+var adapterRecipes = {
+  react: {
+    adapter: "react",
+    displayName: "React",
+    packageName: "@marwes-ui/react",
+    installPackages: ["@marwes-ui/react", "react", "react-dom"],
+    providerImport: "MarwesProvider",
+    viteTemplate: "react-ts",
+    rootFiles: ["src/main.tsx", "src/main.jsx"]
+  },
+  vue: {
+    adapter: "vue",
+    displayName: "Vue",
+    packageName: "@marwes-ui/vue",
+    installPackages: ["@marwes-ui/vue", "vue"],
+    providerImport: "MarwesProvider",
+    viteTemplate: "vue-ts",
+    rootFiles: ["src/App.vue", "src/main.ts"]
+  },
+  svelte: {
+    adapter: "svelte",
+    displayName: "Svelte",
+    packageName: "@marwes-ui/svelte",
+    installPackages: ["@marwes-ui/svelte"],
+    providerImport: "MarwesProvider",
+    viteTemplate: "svelte-ts",
+    rootFiles: ["src/App.svelte"]
+  }
+};
+function isAdapter(value) {
+  return adapters.includes(value);
+}
+function isPackageManager(value) {
+  return packageManagers.includes(value);
+}
+function isMarwesTemplate(value) {
+  return marwesTemplates.includes(value);
+}
+function getAdapterRecipe(adapter) {
+  return adapterRecipes[adapter];
+}
+function adapterFromTemplate(template) {
+  if (template === "react-ts") {
+    return "react";
+  }
+  if (template === "vue-ts") {
+    return "vue";
+  }
+  return "svelte";
+}
+function packageRunnerCommand(packageManager, packageName = "@marwes-ui/cli") {
+  if (packageManager === "pnpm") {
+    return `pnpm dlx ${packageName}`;
+  }
+  if (packageManager === "npm") {
+    return `npx ${packageName}`;
+  }
+  if (packageManager === "yarn") {
+    return `yarn dlx ${packageName}`;
+  }
+  return `bunx ${packageName}`;
+}
+function createAgenticInitCommand(adapter, packageManager) {
+  return `${packageRunnerCommand(packageManager)} init --adapter ${adapter} --agentic`;
+}
+function createAiPrompt(adapter, packageManager) {
+  const recipe = getAdapterRecipe(adapter);
+  const installCommand2 = createAgenticInitCommand(adapter, packageManager);
+  return [
+    `Install and wire Marwes UI for a ${recipe.displayName} app using ${packageManager}.`,
+    `Run: ${installCommand2}.`,
+    "Follow the CLI output exactly.",
+    `If automatic patching is skipped, wrap the app root with ${recipe.providerImport} from ${recipe.packageName}.`,
+    `Import Marwes components, enums, hooks/helpers, and theme tokens only from ${recipe.packageName}.`,
+    "Do not install @marwes-ui/core or @marwes-ui/presets directly.",
+    `Do not add a separate Marwes stylesheet import; the ${recipe.displayName} adapter loads the default styles automatically.`,
+    "Add a small smoke render, for example a Marwes Button, after the installer completes."
+  ].join("\n");
+}
+function supportedAdaptersLabel() {
+  return adapters.join("|");
+}
+function supportedPackageManagersLabel() {
+  return packageManagers.join("|");
+}
+function supportedTemplatesLabel() {
+  return marwesTemplates.join("|");
+}
+
+// src/doctor.ts
+var sourceExtensions = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte", ".css"]);
+function dependencyVersion(packageJson, packageName) {
+  return packageJson.dependencies?.[packageName] ?? packageJson.devDependencies?.[packageName] ?? packageJson.peerDependencies?.[packageName] ?? packageJson.optionalDependencies?.[packageName];
+}
+async function readPackageJson(cwd) {
+  const source = await readFile(join(cwd, "package.json"), "utf8");
+  return JSON.parse(source);
+}
+async function collectSourceFiles(directory) {
+  const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+  const files = [];
+  for (const entry of entries) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") {
+        continue;
+      }
+      files.push(...await collectSourceFiles(path));
+      continue;
+    }
+    const extension = entry.name.slice(entry.name.lastIndexOf("."));
+    if (sourceExtensions.has(extension)) {
+      files.push(path);
+    }
+  }
+  return files;
+}
+function detectInstalledAdapter(packageJson) {
+  return adapters.find(
+    (adapter) => dependencyVersion(packageJson, getAdapterRecipe(adapter).packageName)
+  );
+}
+async function sourceContains(cwd, needle) {
+  const sourceFiles = await collectSourceFiles(join(cwd, "src"));
+  for (const file of sourceFiles) {
+    const source = await readFile(file, "utf8");
+    if (source.includes(needle)) {
+      return true;
+    }
+  }
+  return false;
+}
+function formatItem(item) {
+  const prefix = item.level === "pass" ? "[pass]" : item.level === "warn" ? "[warn]" : "[fail]";
+  return item.fix ? `${prefix} ${item.message}
+       fix: ${item.fix}` : `${prefix} ${item.message}`;
+}
+async function runDoctor(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const write = options.write ?? ((message) => console.log(message));
+  const runner = options.runner ?? defaultCommandRunner;
+  const packageJson = await readPackageJson(cwd);
+  const adapter = options.adapter ?? detectInstalledAdapter(packageJson);
+  const items = [];
+  if (!adapter) {
+    items.push({
+      level: "fail",
+      message: "No Marwes adapter dependency found.",
+      fix: "Run marwes init --adapter react, marwes init --adapter vue, or marwes init --adapter svelte."
+    });
+  } else {
+    const recipe = getAdapterRecipe(adapter);
+    for (const packageName of recipe.installPackages) {
+      if (dependencyVersion(packageJson, packageName)) {
+        items.push({ level: "pass", message: `${packageName} is installed.` });
+      } else {
+        items.push({
+          level: "fail",
+          message: `${packageName} is missing.`,
+          fix: `${options.packageManager ?? await detectPackageManager(cwd)} add ${recipe.installPackages.join(" ")}`
+        });
+      }
+    }
+    const hasProvider = await sourceContains(cwd, "MarwesProvider");
+    items.push(
+      hasProvider ? { level: "pass", message: "MarwesProvider is referenced in app source." } : {
+        level: "warn",
+        message: "MarwesProvider was not found in app source.",
+        fix: `Wrap the app root with MarwesProvider from ${recipe.packageName}.`
+      }
+    );
+  }
+  for (const internalPackage of ["@marwes-ui/core", "@marwes-ui/presets"]) {
+    if (dependencyVersion(packageJson, internalPackage)) {
+      items.push({
+        level: "warn",
+        message: `${internalPackage} is installed directly.`,
+        fix: "App projects should import from the public adapter package instead."
+      });
+    }
+  }
+  if (await sourceContains(cwd, "@marwes-ui/presets/firstEdition/styles.css")) {
+    items.push({
+      level: "warn",
+      message: "Manual Marwes preset stylesheet import found.",
+      fix: "Remove the stylesheet import; adapter packages load the default styles automatically."
+    });
+  }
+  if (options.runBuild) {
+    const packageManager = options.packageManager ?? await detectPackageManager(cwd);
+    const scriptName = packageJson.scripts?.typecheck ? "typecheck" : packageJson.scripts?.build ? "build" : void 0;
+    if (!scriptName) {
+      items.push({ level: "warn", message: "No typecheck or build script found to run." });
+    } else {
+      const command = runScriptCommand(packageManager, scriptName);
+      write(`Running ${formatShellCommand(command)}`);
+      const exitCode2 = await runner(command, { cwd });
+      items.push(
+        exitCode2 === 0 ? { level: "pass", message: `${scriptName} completed successfully.` } : { level: "fail", message: `${scriptName} failed.` }
+      );
+    }
+  }
+  for (const item of items) {
+    write(formatItem(item));
+  }
+  const exitCode = items.some((item) => item.level === "fail") ? 1 : 0;
+  return { ...adapter ? { adapter } : {}, items, exitCode };
+}
+function adapterFromString(value) {
+  return isAdapter(value) ? value : void 0;
+}
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function insertImport(source, importLine) {
+  if (source.includes(importLine)) {
+    return source;
+  }
+  const lines = source.split("\n");
+  let lastImportIndex = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index]?.startsWith("import ")) {
+      lastImportIndex = index;
+    }
+  }
+  if (lastImportIndex === -1) {
+    return `${importLine}
+${source}`;
+  }
+  lines.splice(lastImportIndex + 1, 0, importLine);
+  return lines.join("\n");
+}
+function indentBlock(source, indentation) {
+  return source.split("\n").map((line) => line.trim().length === 0 ? "" : `${indentation}${line}`).join("\n");
+}
+async function writeIfNeeded(path, source, dryRun) {
+  const current = await readFile(path, "utf8");
+  if (current === source) {
+    return false;
+  }
+  if (!dryRun) {
+    await writeFile(path, source);
+  }
+  return true;
+}
+async function patchReact(cwd, dryRun) {
+  const candidates = ["src/main.tsx", "src/main.jsx"];
+  let relativeFile;
+  for (const candidate of candidates) {
+    if (await fileExists(join(cwd, candidate))) {
+      relativeFile = candidate;
+      break;
+    }
+  }
+  if (!relativeFile) {
+    return {
+      adapter: "react",
+      changed: false,
+      dryRun,
+      message: "No React Vite entrypoint found. Expected src/main.tsx or src/main.jsx."
+    };
+  }
+  const file = join(cwd, relativeFile);
+  const source = await readFile(file, "utf8");
+  if (source.includes("MarwesProvider")) {
+    return {
+      adapter: "react",
+      changed: false,
+      dryRun,
+      file: relativeFile,
+      message: "React entrypoint already references MarwesProvider."
+    };
+  }
+  if (!source.includes("<App />")) {
+    return {
+      adapter: "react",
+      changed: false,
+      dryRun,
+      file: relativeFile,
+      message: "React entrypoint did not contain the standard <App /> starter render."
+    };
+  }
+  const withImport = insertImport(source, 'import { MarwesProvider } from "@marwes-ui/react"');
+  const next = withImport.replace(
+    "<App />",
+    ["<MarwesProvider>", "      <App />", "    </MarwesProvider>"].join("\n")
+  );
+  const changed = await writeIfNeeded(file, next, dryRun);
+  return {
+    adapter: "react",
+    changed,
+    dryRun,
+    file: relativeFile,
+    message: changed ? "Wrapped the React root render with MarwesProvider." : "React entrypoint already matched the expected MarwesProvider setup."
+  };
+}
+function ensureVueScript(source) {
+  if (source.includes('MarwesProvider } from "@marwes-ui/vue"')) {
+    return source;
+  }
+  const importLine = 'import { MarwesProvider } from "@marwes-ui/vue"';
+  const scriptSetupMatch = source.match(/<script\s+setup[^>]*>/);
+  if (!scriptSetupMatch?.index && scriptSetupMatch?.index !== 0) {
+    return `<script setup lang="ts">
+${importLine}
+</script>
+
+${source}`;
+  }
+  const insertAt = scriptSetupMatch.index + scriptSetupMatch[0].length;
+  return `${source.slice(0, insertAt)}
+${importLine}${source.slice(insertAt)}`;
+}
+async function patchVue(cwd, dryRun) {
+  const relativeFile = "src/App.vue";
+  const file = join(cwd, relativeFile);
+  if (!await fileExists(file)) {
+    return {
+      adapter: "vue",
+      changed: false,
+      dryRun,
+      message: "No Vue starter component found. Expected src/App.vue."
+    };
+  }
+  const source = await readFile(file, "utf8");
+  if (source.includes("<MarwesProvider")) {
+    return {
+      adapter: "vue",
+      changed: false,
+      dryRun,
+      file: relativeFile,
+      message: "Vue starter component already contains MarwesProvider."
+    };
+  }
+  const templateMatch = source.match(/<template>([\s\S]*?)<\/template>/);
+  if (!templateMatch) {
+    return {
+      adapter: "vue",
+      changed: false,
+      dryRun,
+      file: relativeFile,
+      message: "Vue starter component did not contain a standard <template> block."
+    };
+  }
+  const innerTemplate = templateMatch[1]?.trim();
+  if (!innerTemplate) {
+    return {
+      adapter: "vue",
+      changed: false,
+      dryRun,
+      file: relativeFile,
+      message: "Vue starter template was empty."
+    };
+  }
+  const wrappedTemplate = [
+    "<template>",
+    "  <MarwesProvider>",
+    indentBlock(innerTemplate, "    "),
+    "  </MarwesProvider>",
+    "</template>"
+  ].join("\n");
+  const withProviderTemplate = source.replace(templateMatch[0], wrappedTemplate);
+  const next = ensureVueScript(withProviderTemplate);
+  const changed = await writeIfNeeded(file, next, dryRun);
+  return {
+    adapter: "vue",
+    changed,
+    dryRun,
+    file: relativeFile,
+    message: changed ? "Wrapped the Vue starter template with MarwesProvider." : "Vue starter component already matched the expected MarwesProvider setup."
+  };
+}
+function blockMatches(source, tagName) {
+  return source.match(new RegExp(`<${tagName}[^>]*>[\\s\\S]*?<\\/${tagName}>`, "g")) ?? [];
+}
+function removeBlocks(source, blocks) {
+  return blocks.reduce((next, block) => next.replace(block, ""), source);
+}
+function ensureSvelteScript(scriptBlocks) {
+  const importLine = '  import { MarwesProvider } from "@marwes-ui/svelte"';
+  const script = scriptBlocks[0];
+  if (!script) {
+    return `<script lang="ts">
+${importLine}
+</script>`;
+  }
+  if (script.includes("MarwesProvider")) {
+    return script;
+  }
+  return script.replace(/<script([^>]*)>/i, `<script$1>
+${importLine}`);
+}
+async function patchSvelte(cwd, dryRun) {
+  const relativeFile = "src/App.svelte";
+  const file = join(cwd, relativeFile);
+  if (!await fileExists(file)) {
+    return {
+      adapter: "svelte",
+      changed: false,
+      dryRun,
+      message: "No Svelte starter component found. Expected src/App.svelte."
+    };
+  }
+  const source = await readFile(file, "utf8");
+  if (source.includes("<MarwesProvider")) {
+    return {
+      adapter: "svelte",
+      changed: false,
+      dryRun,
+      file: relativeFile,
+      message: "Svelte starter component already contains MarwesProvider."
+    };
+  }
+  const scriptBlocks = blockMatches(source, "script");
+  const styleBlocks = blockMatches(source, "style");
+  const body = removeBlocks(source, [...scriptBlocks, ...styleBlocks]).trim();
+  if (!body) {
+    return {
+      adapter: "svelte",
+      changed: false,
+      dryRun,
+      file: relativeFile,
+      message: "Svelte starter component had no markup to wrap."
+    };
+  }
+  const script = ensureSvelteScript(scriptBlocks);
+  const styles = styleBlocks.join("\n\n");
+  const next = [
+    script,
+    "",
+    "<MarwesProvider>",
+    indentBlock(body, "  "),
+    "</MarwesProvider>",
+    styles ? `
+${styles}` : ""
+  ].filter(Boolean).join("\n");
+  const changed = await writeIfNeeded(file, `${next.trimEnd()}
+`, dryRun);
+  return {
+    adapter: "svelte",
+    changed,
+    dryRun,
+    file: relativeFile,
+    message: changed ? "Wrapped the Svelte starter markup with MarwesProvider." : "Svelte starter component already matched the expected MarwesProvider setup."
+  };
+}
+async function patchProject(cwd, adapter, dryRun) {
+  if (adapter === "react") {
+    return patchReact(cwd, dryRun);
+  }
+  if (adapter === "vue") {
+    return patchVue(cwd, dryRun);
+  }
+  return patchSvelte(cwd, dryRun);
+}
+
+// src/init.ts
+function providerGuidance(adapter) {
+  const recipe = getAdapterRecipe(adapter);
+  return `Manual follow-up: wrap the app root with ${recipe.providerImport} from ${recipe.packageName}.`;
+}
+function shouldPrintProviderGuidance(patch) {
+  if (!patch || patch.changed) {
+    return false;
+  }
+  return !patch.message.toLowerCase().includes("already");
+}
+function writeAgenticBoundaryRules(adapter, write) {
+  const recipe = getAdapterRecipe(adapter);
+  write("Agentic rules:");
+  write(`- Import Marwes APIs only from ${recipe.packageName}.`);
+  write("- Do not install @marwes-ui/core or @marwes-ui/presets directly.");
+  write("- Do not add a separate Marwes stylesheet import.");
+}
+async function runInit(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const write = options.write ?? ((message) => console.log(message));
+  const runner = options.runner ?? defaultCommandRunner;
+  const recipe = getAdapterRecipe(options.adapter);
+  const packageManager = options.packageManager ?? await detectPackageManager(cwd);
+  const command = installCommand(packageManager, recipe.installPackages);
+  const commandLabel = formatShellCommand(command);
+  const dryRun = options.dryRun === true;
+  const agentic = options.agentic === true;
+  const noInstall = options.noInstall === true;
+  const noPatch = options.noPatch === true;
+  write(`Marwes init: ${recipe.displayName}`);
+  write(`Package manager: ${packageManager}`);
+  if (agentic) {
+    write("Mode: agentic");
+  }
+  let exitCode = 0;
+  if (noInstall) {
+    write(`Install skipped. Run manually: ${commandLabel}`);
+  } else if (dryRun) {
+    write(`[dry-run] ${commandLabel}`);
+  } else {
+    exitCode = await runner(command, { cwd });
+    if (exitCode !== 0) {
+      return {
+        adapter: options.adapter,
+        packageManager,
+        installCommand: commandLabel,
+        installSkipped: false,
+        patchSkipped: noPatch,
+        exitCode
+      };
+    }
+  }
+  let patch;
+  if (noPatch) {
+    write("Patch skipped.");
+  } else {
+    patch = await patchProject(cwd, options.adapter, dryRun);
+    const patchLabel = patch.file ? `${patch.file}: ${patch.message}` : patch.message;
+    write(dryRun && patch.changed ? `[dry-run] ${patchLabel}` : patchLabel);
+  }
+  let doctor;
+  if (agentic) {
+    if (shouldPrintProviderGuidance(patch) || noPatch) {
+      write(providerGuidance(options.adapter));
+    }
+    writeAgenticBoundaryRules(options.adapter, write);
+    if (dryRun) {
+      write(`[dry-run] marwes doctor --adapter ${options.adapter}`);
+    } else {
+      write("Marwes doctor:");
+      doctor = await runDoctor({
+        adapter: options.adapter,
+        cwd,
+        packageManager,
+        runner,
+        write
+      });
+      exitCode = doctor.exitCode;
+    }
+  }
+  write("Marwes init complete.");
+  return {
+    adapter: options.adapter,
+    packageManager,
+    installCommand: commandLabel,
+    installSkipped: noInstall || dryRun,
+    patchSkipped: noPatch,
+    ...patch ? { patch } : {},
+    ...doctor ? { doctor } : {},
+    exitCode
+  };
+}
+
+// src/create.ts
+async function runCreate(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const write = options.write ?? ((message) => console.log(message));
+  const runner = options.runner ?? defaultCommandRunner;
+  const packageManager = options.packageManager ?? await detectPackageManager(cwd);
+  const command = createViteCommand(packageManager, options.projectName, options.template);
+  const adapter = adapterFromTemplate(options.template);
+  const targetCwd = resolve(cwd, options.projectName);
+  write(`Create Marwes app: ${options.projectName}`);
+  write(`Template: ${options.template}`);
+  if (options.dryRun) {
+    write(`[dry-run] ${formatShellCommand(command)}`);
+    write(`[dry-run] marwes init --adapter ${adapter}`);
+    return {
+      projectName: options.projectName,
+      template: options.template,
+      exitCode: 0
+    };
+  }
+  const createExitCode = await runner(command, { cwd });
+  if (createExitCode !== 0) {
+    return {
+      projectName: options.projectName,
+      template: options.template,
+      exitCode: createExitCode
+    };
+  }
+  const initResult = await runInit({
+    adapter,
+    cwd: targetCwd,
+    packageManager,
+    noInstall: options.noInstall === true,
+    runner,
+    write
+  });
+  return {
+    projectName: options.projectName,
+    template: options.template,
+    exitCode: initResult.exitCode
+  };
+}
+
+// src/index.ts
+function writeHelp(write) {
+  write(`Marwes CLI
+
+Commands:
+  marwes init --adapter <${supportedAdaptersLabel()}> [--agentic]
+  marwes doctor [--adapter <${supportedAdaptersLabel()}]
+  marwes ai-prompt --adapter <${supportedAdaptersLabel()}>
+  marwes create <name> --template <${supportedTemplatesLabel()}>
+
+Options:
+  --pm <${supportedPackageManagersLabel()}>
+  --agentic
+  --dry-run
+  --no-install
+  --no-patch
+`);
+}
+function parsePackageManager(value) {
+  return typeof value === "string" && isPackageManager(value) ? value : void 0;
+}
+async function runMarwesCli(argv, options = {}) {
+  const write = options.write ?? ((message) => console.log(message));
+  const [command, ...args] = argv;
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    writeHelp(write);
+    return 0;
+  }
+  if (command === "init") {
+    const parsed = parseArgs({
+      args,
+      options: {
+        adapter: { type: "string" },
+        pm: { type: "string" },
+        agentic: { type: "boolean" },
+        "dry-run": { type: "boolean" },
+        yes: { type: "boolean" },
+        "no-install": { type: "boolean" },
+        "no-patch": { type: "boolean" }
+      },
+      allowPositionals: true
+    });
+    const adapter = adapterFromString(String(parsed.values.adapter ?? ""));
+    if (!adapter) {
+      write(`Missing or invalid --adapter. Expected one of: ${supportedAdaptersLabel()}`);
+      return 1;
+    }
+    const packageManager = parsePackageManager(parsed.values.pm);
+    const initOptions = {
+      adapter,
+      agentic: parsed.values.agentic === true,
+      dryRun: parsed.values["dry-run"] === true,
+      yes: parsed.values.yes === true,
+      noInstall: parsed.values["no-install"] === true,
+      noPatch: parsed.values["no-patch"] === true,
+      write
+    };
+    if (options.cwd) {
+      initOptions.cwd = options.cwd;
+    }
+    if (packageManager) {
+      initOptions.packageManager = packageManager;
+    }
+    const result = await runInit(initOptions);
+    return result.exitCode;
+  }
+  if (command === "doctor") {
+    const parsed = parseArgs({
+      args,
+      options: {
+        adapter: { type: "string" },
+        pm: { type: "string" },
+        "run-build": { type: "boolean" }
+      },
+      allowPositionals: true
+    });
+    const adapter = adapterFromString(String(parsed.values.adapter ?? ""));
+    const packageManager = parsePackageManager(parsed.values.pm);
+    const doctorOptions = {
+      runBuild: parsed.values["run-build"] === true,
+      write
+    };
+    if (adapter) {
+      doctorOptions.adapter = adapter;
+    }
+    if (options.cwd) {
+      doctorOptions.cwd = options.cwd;
+    }
+    if (packageManager) {
+      doctorOptions.packageManager = packageManager;
+    }
+    const result = await runDoctor(doctorOptions);
+    return result.exitCode;
+  }
+  if (command === "ai-prompt") {
+    const parsed = parseArgs({
+      args,
+      options: {
+        adapter: { type: "string" },
+        pm: { type: "string" }
+      },
+      allowPositionals: true
+    });
+    const adapter = adapterFromString(String(parsed.values.adapter ?? ""));
+    if (!adapter) {
+      write(`Missing or invalid --adapter. Expected one of: ${supportedAdaptersLabel()}`);
+      return 1;
+    }
+    write(createAiPrompt(adapter, parsePackageManager(parsed.values.pm) ?? "pnpm"));
+    return 0;
+  }
+  if (command === "create") {
+    return runCreateMarwesCli(args, options);
+  }
+  write(`Unknown command: ${command}`);
+  writeHelp(write);
+  return 1;
+}
+async function runCreateMarwesCli(argv, options = {}) {
+  const write = options.write ?? ((message) => console.log(message));
+  const parsed = parseArgs({
+    args: argv,
+    options: {
+      template: { type: "string" },
+      pm: { type: "string" },
+      "dry-run": { type: "boolean" },
+      "no-install": { type: "boolean" }
+    },
+    allowPositionals: true
+  });
+  const projectName = parsed.positionals[0];
+  const template = String(parsed.values.template ?? "react-ts");
+  if (!projectName) {
+    write("Missing project name.");
+    return 1;
+  }
+  if (!isMarwesTemplate(template)) {
+    write(`Invalid --template. Expected one of: ${supportedTemplatesLabel()}`);
+    return 1;
+  }
+  const packageManager = parsePackageManager(parsed.values.pm);
+  const createOptions = {
+    projectName,
+    template,
+    dryRun: parsed.values["dry-run"] === true,
+    noInstall: parsed.values["no-install"] === true,
+    write
+  };
+  if (options.cwd) {
+    createOptions.cwd = options.cwd;
+  }
+  if (packageManager) {
+    createOptions.packageManager = packageManager;
+  }
+  const result = await runCreate(createOptions);
+  return result.exitCode;
+}
+
+export { adapters, createAgenticInitCommand, createAiPrompt, getAdapterRecipe, marwesTemplates, packageManagers, packageRunnerCommand, runCreate, runCreateMarwesCli, runDoctor, runInit, runMarwesCli };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map