@asterflow/cli 0.1.0

package/README.md

@@ -0,0 +1,52 @@
+<div align="center">
+
+# @asterflow/cli
+
+![license-info](https://img.shields.io/github/license/AsterFlow/AsterFlow?style=for-the-badge&colorA=302D41&colorB=f9e2af&logoColor=f9e2af)
+![stars-info](https://img.shields.io/github/stars/AsterFlow/AsterFlow?colorA=302D41&colorB=f9e2af&style=for-the-badge)
+![last-commit](https://img.shields.io/github/last-commit/AsterFlow/AsterFlow?path=packages%2Fcli&style=for-the-badge&colorA=302D41&colorB=b4befe)
+
+![bundle-size](https://img.shields.io/bundlejs/size/@asterflow/cli?style=for-the-badge&colorA=302D41&colorB=3ac97b)
+
+</div>
+
+> CLI for scaffolding AsterFlow projects, adding plugins, and generating the static fs-routing manifest.
+
+## 📦 Installation
+
+```bash
+bunx @asterflow/cli init my-app
+```
+
+### ✨ Features
+
+- **Full project scaffolding**: `init` writes `package.json`, `tsconfig.json`, `.gitignore`, an app entry for the chosen adapter (Bun, Node, Express or Fastify), and example route files - interactively or entirely via flags.
+- **Non-interactive by default when it needs to be**: any `--flag`, CI, or `--yes` skips prompting and fills in documented defaults instead, so agents and CI never hang waiting on input.
+- **Empty-directory check**: refuses to scaffold into a non-empty directory (ignoring things like `.git`/`.gitignore`/an IDE folder).
+- **Plugin management**: `add` merges plugins into an existing project's `package.json`, installs them with the detected package manager, and prints the `.use(...)` snippet to wire each one up.
+- **Route templates**: `hello` (a minimal `GET /`) and `upload` (a file upload via `@asterflow/multipart`, only offered when the `multipart` plugin is selected).
+- **Static route manifest generation**: `generate` calls `@asterflow/fs`'s `generateRouteManifest` to turn a `routes/` directory into a manifest of static imports, with a `--watch` mode to regenerate on change.
+
+## ❓ How to Use
+
+Scaffold a new project - interactively, or fully via flags for CI/agents:
+
+```bash
+bunx @asterflow/cli init my-app --adapter bun --plugins fs,multipart --routes hello,upload --yes
+```
+
+Manage an existing project with the other commands:
+
+```bash
+asterflow add fs,multipart   # add plugins to package.json, install them, print .use(...) wiring
+asterflow list                # print available plugins
+asterflow generate --watch    # regenerate src/routes.gen.ts whenever src/routes/ changes
+```
+
+## 🔗 Related Packages
+
+- [@asterflow/fs](https://www.npmjs.com/package/@asterflow/fs) - its `generateRouteManifest` powers the `generate` command.
+
+## 📄 License
+
+This project is licensed under the [MIT License](../../LICENSE).

package/dist/cjs/index.cjs

@@ -0,0 +1,637 @@
+#!/usr/bin/env node
+"use strict";
+var Ae = Object.create;
+var q = Object.defineProperty;
+var Re = Object.getOwnPropertyDescriptor;
+var Ne = Object.getOwnPropertyNames;
+var Te = Object.getPrototypeOf, Ce = Object.prototype.hasOwnProperty;
+var De = (e, t, r, o) => {
+  if (t && typeof t == "object" || typeof t == "function")
+    for (let l of Ne(t))
+      !Ce.call(e, l) && l !== r && q(e, l, { get: () => t[l], enumerable: !(o = Re(t, l)) || o.enumerable });
+  return e;
+};
+var $ = (e, t, r) => (r = e != null ? Ae(Te(e)) : {}, De(
+  t || !e || !e.__esModule ? q(r, "default", { value: e, enumerable: !0 }) : r,
+  e
+));
+// packages/cli/src/index.ts
+var Ie = $(require("yargs"), 1), Ee = require("yargs/helpers");
+// packages/cli/src/commands/add.ts
+var ee = require("child_process"), te = require("fs"), T = require("fs/promises"), C = require("path"), re = require("util");
+// packages/cli/src/registry/plugins.ts
+var b = {
+  fs: {
+    id: "fs",
+    packageName: "@asterflow/fs",
+    version: "^1.0.7",
+    description: "File system-based routing - routes are discovered from a routes/ directory.",
+    importName: "fsRoutingPlugin",
+    useSnippet: ".use(fsRoutingPlugin, { routes })",
+    usageNote: "Run `asterflow generate` (or `asterflow generate --watch`) after adding/removing files under src/routes/ - it writes src/routes.gen.ts, which the app entry imports as `routes`."
+  },
+  multipart: {
+    id: "multipart",
+    packageName: "@asterflow/multipart",
+    version: "^1.0.0",
+    description: "multipart/form-data parsing (file uploads), with per-route type-safe field criteria.",
+    importName: "multipartPlugin",
+    useSnippet: ".use(multipartPlugin, { limits: { fileSize: 10 * 1024 * 1024 } })",
+    usageNote: "Build upload routes with Method.create(Method.POST).multipart({...}).handler(...) - see src/routes/upload.ts for a working example."
+  }
+}, Je = Object.keys(b);
+// packages/cli/src/utils/log.ts
+var j = $(require("chalk"), 1), d = {
+  info: (e) => console.log(j.default.cyan(e)),
+  success: (e) => console.log(j.default.green(e)),
+  warn: (e) => console.log(j.default.yellow(e)),
+  error: (e) => console.error(j.default.red(e)),
+  step: (e) => console.log(j.default.gray(`  ${e}`))
+};
+// packages/cli/src/utils/packageManager.ts
+var K = require("fs"), H = require("path"), Oe = {
+  "bun.lock": "bun",
+  "bun.lockb": "bun",
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm"
+};
+function G(e) {
+  for (let [t, r] of Object.entries(Oe))
+    if ((0, K.existsSync)((0, H.join)(e, t))) return r;
+  return "bun";
+}
+function Q(e, t) {
+  return e ?? G(t);
+}
+function X(e) {
+  return e === "yarn" ? "yarn" : `${e} install`;
+}
+function Z(e, t) {
+  let r = t.join(" ");
+  switch (e) {
+    case "bun":
+      return `bun add ${r}`;
+    case "pnpm":
+      return `pnpm add ${r}`;
+    case "yarn":
+      return `yarn add ${r}`;
+    case "npm":
+      return `npm install ${r}`;
+  }
+}
+// packages/cli/src/commands/add.ts
+var Fe = (0, re.promisify)(ee.exec);
+async function ne({ names: e, directory: t }) {
+  let r = (0, C.resolve)(t ?? "."), o = (0, C.join)(r, "package.json"), l = e.split(",").map((a) => a.trim()).filter(Boolean);
+  if (l.length === 0) {
+    d.error("No plugin names given. Usage: asterflow add fs,multipart"), process.exitCode = 1;
+    return;
+  }
+  let h = l.filter((a) => !b[a]);
+  if (h.length > 0) {
+    d.error(`Unknown plugin${h.length > 1 ? "s" : ""}: ${h.join(", ")}`), d.step(`Available plugins: ${Object.keys(b).join(", ")}`), process.exitCode = 1;
+    return;
+  }
+  if (!(0, te.existsSync)(o)) {
+    d.error(`No package.json found at ${o}. Run this from an AsterFlow project (or \`asterflow init\` first).`), process.exitCode = 1;
+    return;
+  }
+  let u = l.map((a) => b[a]), p = await (0, T.readFile)(o, "utf-8"), c = JSON.parse(p);
+  c.dependencies ??= {};
+  let g = u.filter((a) => c.dependencies[a.packageName]), y = u.filter((a) => !c.dependencies[a.packageName]);
+  for (let a of y) c.dependencies[a.packageName] = a.version;
+  if (c.dependencies = Object.fromEntries(Object.entries(c.dependencies).sort(([a], [w]) => a.localeCompare(w))), y.length > 0) {
+    await (0, T.writeFile)(o, `${JSON.stringify(c, null, 2)}
+`), d.success(`Added to package.json: ${y.map((x) => x.packageName).join(", ")}`);
+    let a = G(r), w = Z(a, y.map((x) => x.packageName));
+    d.info(`Installing (${w})...`);
+    try {
+      await Fe(w, { cwd: r }), d.success("Dependencies installed.");
+    } catch (x) {
+      d.error(`Install failed - run manually: ${w}`), d.step(x instanceof Error ? x.message : String(x));
+    }
+  }
+  g.length > 0 && d.warn(`Already present, skipped: ${g.map((a) => a.packageName).join(", ")}`), d.info("Wire it up:");
+  for (let a of u)
+    d.step(`import { ${a.importName} } from '${a.packageName}'`), d.step(`app${a.useSnippet}`), d.step(a.usageNote);
+}
+// packages/cli/src/commands/generate.ts
+var oe = require("@asterflow/fs"), se = require("fs"), I = require("path");
+var Me = "src/routes", ie = "src/routes.gen.ts";
+async function ae({ directory: e, out: t, watch: r }) {
+  let o = (0, I.resolve)(e ?? Me), l = (0, I.resolve)(t ?? ie), h = async () => {
+    try {
+      await (0, oe.generateRouteManifest)({ routesDir: o, outFile: l }), d.success(`Generated ${(0, I.join)(t ?? ie)}`);
+    } catch (p) {
+      d.error(p instanceof Error ? p.message : String(p)), r || (process.exitCode = 1);
+    }
+  };
+  if (await h(), !r) return;
+  d.info(`Watching ${o} for changes...`);
+  let u;
+  (0, se.watch)(o, { recursive: !0 }, () => {
+    clearTimeout(u), u = setTimeout(h, 100);
+  });
+}
+// packages/cli/src/commands/init.ts
+var i = $(require("@clack/prompts"), 1), V = $(require("ci-info"), 1), ve = require("child_process"), k = require("fs/promises"), m = require("path"), Pe = require("util");
+// packages/cli/src/generators/appEntry.ts
+function le({ adapter: e, plugins: t, stub: r }) {
+  let o = t.some((p) => p.id === "fs"), l = [
+    "import { AsterFlow } from 'asterflow'",
+    "import { adapters } from '@asterflow/adapter'",
+    ...e.imports,
+    ...t.map((p) => `import { ${p.importName} } from '${p.packageName}'`),
+    ...o ? ["import routes from './routes.gen'"] : []
+  ], h = [
+    ...t.map((p) => p.useSnippet.replace(/^\./, "")),
+    ...!o && r ? [`method('get', {
+    path: '/',
+    handler({ response }) {
+      return response.success({ message: 'Hello from AsterFlow!' })
+    }
+  })`] : [],
+    `listen${e.listenCall}`
+  ], u = e.preamble ? `${e.preamble}
+` : "";
+  return `${l.join(`
+`)}
+${u}export default new AsterFlow({ driver: ${e.driverExpression} })
+  .${h.join(`
+  .`)}
+`;
+}
+// packages/cli/src/generators/packageJson.ts
+function pe({ name: e, adapter: t, plugins: r }) {
+  let o = r.some((g) => g.id === "fs"), l = {
+    asterflow: "^0.0.5",
+    "@asterflow/adapter": "^1.0.0",
+    zod: "^3.25.67"
+  };
+  t.dependency && (l[t.dependency] = "latest");
+  for (let g of r) l[g.packageName] = g.version;
+  let h = Object.fromEntries(Object.entries(l).sort(([g], [y]) => g.localeCompare(y))), u = o ? {
+    predev: "asterflow generate",
+    dev: "bun run src/index.ts",
+    prebuild: "asterflow generate"
+  } : { dev: "bun run src/index.ts" }, p = {
+    typescript: "^5.8.3",
+    "@types/bun": "latest"
+  };
+  return o && (p["@asterflow/cli"] = "^0.1.0"), `${JSON.stringify({
+    name: e,
+    version: "0.1.0",
+    type: "module",
+    private: !0,
+    scripts: u,
+    dependencies: h,
+    devDependencies: p
+  }, null, 2)}
+`;
+}
+// packages/cli/src/helpers/copyTemplate.ts
+var D = require("fs/promises"), L = require("path"), _e = (0, L.join)(__dirname, "..", "..", "templates");
+async function U(e) {
+  return (0, D.readFile)((0, L.join)(_e, e), "utf-8");
+}
+async function B(e, t) {
+  let r = await U(e);
+  await (0, D.writeFile)(t, r);
+}
+// packages/cli/src/registry/templates.ts
+var ce = {
+  hello: {
+    id: "hello",
+    path: "/",
+    source: "routes/index.ts",
+    summary: "Minimal GET route at the root path."
+  },
+  upload: {
+    id: "upload",
+    path: "/upload",
+    source: "routes/upload.ts",
+    plugin: "multipart",
+    summary: "File upload handled by @asterflow/multipart."
+  }
+}, E = Object.keys(ce);
+function O(e) {
+  let t = new Set(e);
+  return E.map((r) => ce[r]).filter((r) => !r.plugin || t.has(r.plugin));
+}
+function de(e) {
+  let t = e.path.replace(/^\/+|\/+$/g, "");
+  return t.length === 0 ? "index.ts" : `${t}/index.ts`;
+}
+// packages/cli/src/generators/routes.ts
+async function me({ pluginIds: e, templateIds: t }) {
+  if (!e.includes("fs")) return [];
+  let r = O(e).filter((o) => t.includes(o.id));
+  return Promise.all(r.map(async (o) => ({
+    fileName: de(o),
+    content: await U(o.source)
+  })));
+}
+// packages/cli/src/helpers/git.ts
+var P = require("child_process"), ue = require("fs"), ge = require("path");
+function Ge(e) {
+  try {
+    return (0, P.execSync)("git rev-parse --is-inside-work-tree", { cwd: e, stdio: "ignore" }), !0;
+  } catch {
+    return !1;
+  }
+}
+function Le(e) {
+  try {
+    return (0, P.execSync)("git config init.defaultBranch", { cwd: e, stdio: "ignore" }), !0;
+  } catch {
+    return !1;
+  }
+}
+function fe(e) {
+  let t = !1;
+  try {
+    return (0, P.execSync)("git --version", { stdio: "ignore" }), Ge(e) ? !1 : ((0, P.execSync)("git init", { cwd: e, stdio: "ignore" }), t = !0, Le(e) || (0, P.execSync)("git checkout -b main", { cwd: e, stdio: "ignore" }), (0, P.execSync)("git add -A", { cwd: e, stdio: "ignore" }), (0, P.execSync)('git commit -m "Initial commit from create-asterflow-app"', { cwd: e, stdio: "ignore" }), !0);
+  } catch {
+    if (t)
+      try {
+        (0, ue.rmSync)((0, ge.join)(e, ".git"), { recursive: !0, force: !0 });
+      } catch {
+      }
+    return !1;
+  }
+}
+// packages/cli/src/helpers/isFolderEmpty.ts
+var F = require("fs"), ye = require("path"), W = $(require("chalk"), 1), Ue =  new Set([
+  ".DS_Store",
+  ".git",
+  ".gitattributes",
+  ".gitignore",
+  ".gitlab-ci.yml",
+  ".hg",
+  ".hgcheck",
+  ".hgignore",
+  ".idea",
+  ".npmignore",
+  ".vscode",
+  "LICENSE",
+  "Thumbs.db"
+]);
+function be(e, t) {
+  let r = (0, F.readdirSync)(e).filter((o) => !Ue.has(o) && !o.endsWith(".iml"));
+  if (r.length === 0) return !0;
+  console.log(`The directory ${W.default.green(t)} contains files that could conflict:`), console.log();
+  for (let o of r) {
+    let l = (0, F.lstatSync)((0, ye.join)(e, o)).isDirectory();
+    console.log(`  ${W.default.cyan(o)}${l ? "/" : ""}`);
+  }
+  return console.log(), console.log("Either try using a new directory name, or remove the files listed above."), console.log(), !1;
+}
+// packages/cli/src/helpers/isWriteable.ts
+var he = require("fs"), we = require("fs/promises");
+async function ke(e) {
+  try {
+    return await (0, we.access)(e, he.constants.W_OK), !0;
+  } catch {
+    return !1;
+  }
+}
+// packages/cli/src/helpers/validateProjectName.ts
+var xe = $(require("validate-npm-package-name"), 1);
+function Y(e) {
+  let t = (0, xe.default)(e);
+  return t.validForNewPackages ? { valid: !0 } : {
+    valid: !1,
+    problems: [...t.errors ?? [], ...t.warnings ?? []]
+  };
+}
+// packages/cli/src/registry/adapters.ts
+var S = {
+  bun: {
+    id: "bun",
+    label: "Bun (native Bun.serve)",
+    dependency: null,
+    imports: [],
+    driverExpression: "adapters.bun",
+    preamble: null,
+    listenCall: `({ port: 3333 }, (err) => {
+    if (err) {
+      console.error(err)
+      process.exit(1)
+    }
+    console.log('Server listening on http:
+  })`
+  },
+  node: {
+    id: "node",
+    label: "Node.js (native http)",
+    dependency: null,
+    imports: [],
+    driverExpression: "adapters.node",
+    preamble: null,
+    listenCall: `({ port: 3333 }, (err) => {
+    if (err) {
+      console.error(err)
+      process.exit(1)
+    }
+    console.log('Server listening on http:
+  })`
+  },
+  express: {
+    id: "express",
+    label: "Express",
+    dependency: "express",
+    imports: ["import express from 'express'"],
+    driverExpression: "adapters.express",
+    preamble: "const server = express()",
+    listenCall: `(server, 3333, () => {
+    console.log('Server listening on http:
+  })`
+  },
+  fastify: {
+    id: "fastify",
+    label: "Fastify",
+    dependency: "fastify",
+    imports: ["import fastify from 'fastify'"],
+    driverExpression: "adapters.fastify",
+    preamble: "const server = fastify()",
+    listenCall: `(server, { port: 3333 }, (err) => {
+    if (err) {
+      console.error(err)
+      process.exit(1)
+    }
+    console.log('Server listening on http:
+  })`
+  }
+}, A = Object.keys(S);
+// packages/cli/src/commands/init.ts
+var Be = (0, Pe.promisify)(ve.exec), v = {
+  adapter: "bun",
+  plugins: ["fs", "multipart"],
+  install: !0,
+  git: !0
+};
+async function $e(e) {
+  i.intro("Create a new AsterFlow project");
+  let t = (0, m.resolve)(e.directory ?? "."), r = (0, m.basename)(t) === "." ? "my-asterflow-app" : (0, m.basename)(t);
+  if (!await ke((0, m.dirname)(t))) {
+    i.cancel(`The path ${t} is not writable. Check folder permissions and try again.`), process.exitCode = 1;
+    return;
+  }
+  if (await (0, k.mkdir)(t, { recursive: !0 }), !be(t, (0, m.basename)(t))) {
+    process.exitCode = 1;
+    return;
+  }
+  let o = process.argv.some((n) => n.startsWith("--")), l = V.default.isCI || !!e.yes || o, h = o && !e.yes && !V.default.isCI;
+  if (e.name) {
+    let n = Y(e.name);
+    if (!n.valid) {
+      i.cancel(`Invalid project name "${e.name}":
+${n.problems.map((s) => `  - ${s}`).join(`
+`)}`), process.exitCode = 1;
+      return;
+    }
+  }
+  let u = e.name;
+  if (u === void 0)
+    if (l)
+      u = r;
+    else {
+      let n = await i.text({
+        message: "Project name",
+        placeholder: r,
+        defaultValue: r,
+        validate: (s) => {
+          let f = Y(s || r);
+          return f.valid ? void 0 : `Invalid project name: ${f.problems[0]}`;
+        }
+      });
+      if (i.isCancel(n)) return i.cancel("Cancelled.");
+      u = n;
+    }
+  if (e.adapter && !S[e.adapter]) {
+    i.cancel(`Unknown adapter "${e.adapter}". Available: ${A.join(", ")}`), process.exitCode = 1;
+    return;
+  }
+  let p = e.adapter;
+  if (!p)
+    if (l)
+      p = v.adapter;
+    else {
+      let n = await i.select({
+        message: "Which adapter do you want to use?",
+        options: Object.values(S).map((s) => ({ value: s.id, label: s.label })),
+        initialValue: v.adapter
+      });
+      if (i.isCancel(n)) return i.cancel("Cancelled.");
+      p = n;
+    }
+  let c;
+  if (e.plugins !== void 0) {
+    c = e.plugins.split(",").map((s) => s.trim()).filter(Boolean);
+    let n = c.filter((s) => !b[s]);
+    if (n.length > 0) {
+      i.cancel(`Unknown plugin${n.length > 1 ? "s" : ""}: ${n.join(", ")}. Available: ${Object.keys(b).join(", ")}`), process.exitCode = 1;
+      return;
+    }
+  } else if (l)
+    c = v.plugins;
+  else {
+    let n = await i.multiselect({
+      message: "Which plugins do you want to install? (space to select, enter to confirm)",
+      options: Object.values(b).map((s) => ({ value: s.id, label: s.packageName, hint: s.description })),
+      initialValues: v.plugins,
+      required: !1
+    });
+    if (i.isCancel(n)) return i.cancel("Cancelled.");
+    c = n;
+  }
+  c.length === 0 && (c = v.plugins);
+  let g = O(c), y;
+  if (e.routes !== void 0) {
+    let n = e.routes.split(",").map((f) => f.trim()).filter(Boolean);
+    y = n.includes("none") ? [] : n;
+    let s = y.filter((f) => !g.some((Se) => Se.id === f));
+    if (s.length > 0) {
+      i.cancel(`Unknown route template${s.length > 1 ? "s" : ""}: ${s.join(", ")}. Available: ${g.map((f) => f.id).join(", ")}`), process.exitCode = 1;
+      return;
+    }
+  } else if (l)
+    y = g.map((n) => n.id);
+  else {
+    let n = await i.multiselect({
+      message: "Which example routes do you want to scaffold? (space to select, enter to confirm)",
+      options: g.map((s) => ({ value: s.id, label: s.path, hint: s.summary })),
+      initialValues: g.map((s) => s.id),
+      required: !1
+    });
+    if (i.isCancel(n)) return i.cancel("Cancelled.");
+    y = n;
+  }
+  let a = e.install;
+  if (a === void 0)
+    if (l)
+      a = v.install;
+    else {
+      let n = await i.confirm({ message: "Install dependencies now?", initialValue: v.install });
+      if (i.isCancel(n)) return i.cancel("Cancelled.");
+      a = n;
+    }
+  let w = e.git;
+  if (w === void 0)
+    if (l)
+      w = v.git;
+    else {
+      let n = await i.confirm({ message: "Initialize a git repository?", initialValue: v.git });
+      if (i.isCancel(n)) return i.cancel("Cancelled.");
+      w = n;
+    }
+  h && We({
+    adapter: e.adapter === void 0,
+    plugins: e.plugins === void 0,
+    routes: e.routes === void 0,
+    install: e.install === void 0,
+    git: e.git === void 0
+  }, { adapterId: p, pluginIds: c, templateIds: y, install: a, git: w });
+  let x = S[p], N = c.map((n) => b[n]), z = i.spinner();
+  z.start("Scaffolding project");
+  let M = (0, m.join)(t, "src");
+  await (0, k.mkdir)(M, { recursive: !0 }), await (0, k.writeFile)((0, m.join)(t, "package.json"), pe({ name: u, adapter: x, plugins: N })), await B("tsconfig.json", (0, m.join)(t, "tsconfig.json")), await (0, k.writeFile)((0, m.join)(M, "index.ts"), le({ adapter: x, plugins: N, stub: y.length > 0 })), await B("gitignore", (0, m.join)(t, ".gitignore")), N.some((n) => n.id === "fs") && await (0, k.appendFile)((0, m.join)(t, ".gitignore"), `src/routes.gen.ts
+`);
+  let J = await me({ pluginIds: c, templateIds: y });
+  if (J.length > 0) {
+    let n = (0, m.join)(M, "routes");
+    await (0, k.mkdir)(n, { recursive: !0 });
+    for (let s of J) {
+      let f = (0, m.join)(n, s.fileName);
+      await (0, k.mkdir)((0, m.dirname)(f), { recursive: !0 }), await (0, k.writeFile)(f, s.content);
+    }
+  }
+  z.stop("Project scaffolded");
+  let _ = Q(e.packageManager, t);
+  if (a) {
+    let n = X(_), s = i.spinner();
+    s.start(`Installing dependencies (${n})`);
+    try {
+      await Be(n, { cwd: t }), s.stop("Dependencies installed");
+    } catch (f) {
+      s.stop("Failed to install dependencies"), i.log.error(f instanceof Error ? f.message : String(f));
+    }
+  }
+  w && fe(t) && i.log.success("Initialized a git repository.");
+  for (let n of N)
+    i.log.info(`${n.packageName}: ${n.usageNote}`);
+  Ye({ name: u, targetDir: t, packageManager: _, useYarn: _ === "yarn" });
+}
+function We(e, t) {
+  let r = [];
+  e.adapter && r.push(`  --adapter <id>   ${t.adapterId}  (available: ${A.join(", ")})`), e.plugins && r.push(`  --plugins <ids>  ${t.pluginIds.length > 0 ? t.pluginIds.join(",") : "none"}  (available: ${Object.keys(b).join(", ")})`), e.routes && r.push(`  --routes <ids>   ${t.templateIds.length > 0 ? t.templateIds.join(",") : "none"}  (available: ${E.join(", ")})`), e.install && r.push(`  --no-install     skip installing dependencies  (default: ${t.install ? "installs" : "skips"})`), e.git && r.push(`  --no-git         skip git init  (default: ${t.git ? "inits" : "skips"})`), r.length !== 0 && i.note(r.join(`
+`), "Using defaults for unprovided options");
+}
+function Ye({ name: e, targetDir: t, packageManager: r, useYarn: o }) {
+  let l = `${r} ${o ? "" : "run "}dev`;
+  i.note(`cd ${t}
+${l}`, "Next steps"), i.outro(`Success! Created ${e} at ${t}`);
+}
+// packages/cli/src/commands/list.ts
+var R = $(require("chalk"), 1);
+function je() {
+  console.log(R.default.bold(`
+Available AsterFlow plugins:
+`));
+  for (let e of Object.values(b))
+    console.log(`  ${R.default.cyan(e.id.padEnd(12))} ${R.default.gray(e.packageName)}`), console.log(`  ${" ".repeat(12)} ${e.description}
+`);
+  console.log(R.default.gray(`Install with: asterflow add <name>[,<name>...]
+`));
+}
+// packages/cli/src/index.ts
+(async () => {
+  await (0, Ie.default)((0, Ee.hideBin)(process.argv)).scriptName("asterflow").command(
+    "init [directory]",
+    "Scaffold a new AsterFlow project",
+    (e) => e.positional("directory", {
+      type: "string",
+      describe: "Directory to create the project in (defaults to the current directory)"
+    }).option("name", {
+      type: "string",
+      describe: "Project name (defaults to the directory name)"
+    }).option("adapter", {
+      type: "string",
+      describe: `Adapter to use (${A.join(", ")})`
+    }).option("plugins", {
+      type: "string",
+      describe: "Comma-separated plugin ids, e.g. fs,multipart"
+    }).option("routes", {
+      type: "string",
+      describe: `Comma-separated route template ids to scaffold, or "none" (${E.join(", ")})`
+    }).option("install", {
+      type: "boolean",
+      describe: "Install dependencies (default: yes)"
+    }).option("skip-install", {
+      type: "boolean",
+      describe: "Alias for --no-install"
+    }).option("git", {
+      type: "boolean",
+      describe: "Initialize a git repository (default: yes)"
+    }).option("use-npm", { type: "boolean", describe: "Install dependencies with npm" }).option("use-pnpm", { type: "boolean", describe: "Install dependencies with pnpm" }).option("use-yarn", { type: "boolean", describe: "Install dependencies with yarn" }).option("use-bun", { type: "boolean", describe: "Install dependencies with bun" }).option("yes", {
+      type: "boolean",
+      describe: "Accept defaults for anything not explicitly set, without prompting"
+    }),
+    async (e) => {
+      let t = e.useNpm ? "npm" : e.usePnpm ? "pnpm" : e.useYarn ? "yarn" : e.useBun ? "bun" : void 0;
+      await $e({
+        directory: e.directory,
+        name: e.name,
+        adapter: e.adapter,
+        plugins: e.plugins,
+        routes: e.routes,
+        install: e.skipInstall ? !1 : e.install,
+        git: e.git,
+        packageManager: t,
+        yes: e.yes
+      });
+    }
+  ).command(
+    "add <names>",
+    "Add one or more plugins to the current project",
+    (e) => e.positional("names", {
+      type: "string",
+      describe: "Comma-separated plugin names, e.g. fs,multipart",
+      demandOption: !0
+    }).option("directory", {
+      alias: "C",
+      type: "string",
+      describe: "Project directory (defaults to the current directory)"
+    }),
+    async (e) => {
+      await ne({ names: e.names, directory: e.directory });
+    }
+  ).command(
+    "list",
+    "List available plugins",
+    () => {
+    },
+    () => je()
+  ).command(
+    "generate [directory]",
+    "Generate the static route manifest consumed by @asterflow/fs (fs-routing)",
+    (e) => e.positional("directory", {
+      type: "string",
+      describe: "Routes directory to scan (defaults to src/routes)"
+    }).option("out", {
+      alias: "o",
+      type: "string",
+      describe: "Output file for the generated manifest (defaults to src/routes.gen.ts)"
+    }).option("watch", {
+      alias: "w",
+      type: "boolean",
+      describe: "Regenerate whenever a file under the routes directory changes"
+    }),
+    async (e) => {
+      await ae({ directory: e.directory, out: e.out, watch: e.watch });
+    }
+  ).demandCommand(1, "Specify a command: init, add, list or generate").strict().help().alias("help", "h").parse();
+})().catch((e) => {
+  console.error(e instanceof Error ? e.message : e), process.exitCode = 1;
+});

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}