@asterflow/cli 0.1.0

package/dist/mjs/index.js

@@ -0,0 +1,644 @@
+#!/usr/bin/env node
+// packages/cli/src/index.ts
+import Ve from "yargs";
+import { hideBin as ze } from "yargs/helpers";
+// packages/cli/src/commands/add.ts
+import { exec as me } from "child_process";
+import { existsSync as ue } from "fs";
+import { readFile as ge, writeFile as fe } from "fs/promises";
+import { join as ye, resolve as be } from "path";
+import { promisify as he } from "util";
+// packages/cli/src/registry/plugins.ts
+var y = {
+  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."
+  }
+}, qe = Object.keys(y);
+// packages/cli/src/utils/log.ts
+import P from "chalk";
+var d = {
+  info: (e) => console.log(P.cyan(e)),
+  success: (e) => console.log(P.green(e)),
+  warn: (e) => console.log(P.yellow(e)),
+  error: (e) => console.error(P.red(e)),
+  step: (e) => console.log(P.gray(`  ${e}`))
+};
+// packages/cli/src/utils/packageManager.ts
+import { existsSync as pe } from "fs";
+import { join as ce } from "path";
+var de = {
+  "bun.lock": "bun",
+  "bun.lockb": "bun",
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm"
+};
+function C(e) {
+  for (let [t, r] of Object.entries(de))
+    if (pe(ce(e, t))) return r;
+  return "bun";
+}
+function U(e, t) {
+  return e ?? C(t);
+}
+function B(e) {
+  return e === "yarn" ? "yarn" : `${e} install`;
+}
+function W(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 we = he(me);
+async function Y({ names: e, directory: t }) {
+  let r = be(t ?? "."), s = ye(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 b = l.filter((a) => !y[a]);
+  if (b.length > 0) {
+    d.error(`Unknown plugin${b.length > 1 ? "s" : ""}: ${b.join(", ")}`), d.step(`Available plugins: ${Object.keys(y).join(", ")}`), process.exitCode = 1;
+    return;
+  }
+  if (!ue(s)) {
+    d.error(`No package.json found at ${s}. Run this from an AsterFlow project (or \`asterflow init\` first).`), process.exitCode = 1;
+    return;
+  }
+  let m = l.map((a) => y[a]), p = await ge(s, "utf-8"), c = JSON.parse(p);
+  c.dependencies ??= {};
+  let u = m.filter((a) => c.dependencies[a.packageName]), f = m.filter((a) => !c.dependencies[a.packageName]);
+  for (let a of f) c.dependencies[a.packageName] = a.version;
+  if (c.dependencies = Object.fromEntries(Object.entries(c.dependencies).sort(([a], [h]) => a.localeCompare(h))), f.length > 0) {
+    await fe(s, `${JSON.stringify(c, null, 2)}
+`), d.success(`Added to package.json: ${f.map((w) => w.packageName).join(", ")}`);
+    let a = C(r), h = W(a, f.map((w) => w.packageName));
+    d.info(`Installing (${h})...`);
+    try {
+      await we(h, { cwd: r }), d.success("Dependencies installed.");
+    } catch (w) {
+      d.error(`Install failed - run manually: ${h}`), d.step(w instanceof Error ? w.message : String(w));
+    }
+  }
+  u.length > 0 && d.warn(`Already present, skipped: ${u.map((a) => a.packageName).join(", ")}`), d.info("Wire it up:");
+  for (let a of m)
+    d.step(`import { ${a.importName} } from '${a.packageName}'`), d.step(`app${a.useSnippet}`), d.step(a.usageNote);
+}
+// packages/cli/src/commands/generate.ts
+import { generateRouteManifest as ke } from "@asterflow/fs";
+import { watch as xe } from "fs";
+import { join as ve, resolve as V } from "path";
+var Pe = "src/routes", z = "src/routes.gen.ts";
+async function J({ directory: e, out: t, watch: r }) {
+  let s = V(e ?? Pe), l = V(t ?? z), b = async () => {
+    try {
+      await ke({ routesDir: s, outFile: l }), d.success(`Generated ${ve(t ?? z)}`);
+    } catch (p) {
+      d.error(p instanceof Error ? p.message : String(p)), r || (process.exitCode = 1);
+    }
+  };
+  if (await b(), !r) return;
+  d.info(`Watching ${s} for changes...`);
+  let m;
+  xe(s, { recursive: !0 }, () => {
+    clearTimeout(m), m = setTimeout(b, 100);
+  });
+}
+// packages/cli/src/commands/init.ts
+import * as i from "@clack/prompts";
+import ie from "ci-info";
+import { exec as _e } from "child_process";
+import { appendFile as Ge, mkdir as A, writeFile as M } from "fs/promises";
+import { basename as _, dirname as oe, join as x, resolve as Le } from "path";
+import { promisify as Ue } from "util";
+// packages/cli/src/generators/appEntry.ts
+function q({ adapter: e, plugins: t, stub: r }) {
+  let s = 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}'`),
+    ...s ? ["import routes from './routes.gen'"] : []
+  ], b = [
+    ...t.map((p) => p.useSnippet.replace(/^\./, "")),
+    ...!s && r ? [`method('get', {
+    path: '/',
+    handler({ response }) {
+      return response.success({ message: 'Hello from AsterFlow!' })
+    }
+  })`] : [],
+    `listen${e.listenCall}`
+  ], m = e.preamble ? `${e.preamble}
+` : "";
+  return `${l.join(`
+`)}
+${m}export default new AsterFlow({ driver: ${e.driverExpression} })
+  .${b.join(`
+  .`)}
+`;
+}
+// packages/cli/src/generators/packageJson.ts
+function K({ name: e, adapter: t, plugins: r }) {
+  let s = r.some((u) => u.id === "fs"), l = {
+    asterflow: "^0.0.5",
+    "@asterflow/adapter": "^1.0.0",
+    zod: "^3.25.67"
+  };
+  t.dependency && (l[t.dependency] = "latest");
+  for (let u of r) l[u.packageName] = u.version;
+  let b = Object.fromEntries(Object.entries(l).sort(([u], [f]) => u.localeCompare(f))), m = s ? {
+    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 s && (p["@asterflow/cli"] = "^0.1.0"), `${JSON.stringify({
+    name: e,
+    version: "0.1.0",
+    type: "module",
+    private: !0,
+    scripts: m,
+    dependencies: b,
+    devDependencies: p
+  }, null, 2)}
+`;
+}
+// packages/cli/src/helpers/copyTemplate.ts
+import { readFile as $e, writeFile as je } from "fs/promises";
+import { join as H } from "path";
+var Ie = H(__dirname, "..", "..", "templates");
+async function D(e) {
+  return $e(H(Ie, e), "utf-8");
+}
+async function O(e, t) {
+  let r = await D(e);
+  await je(t, r);
+}
+// packages/cli/src/registry/templates.ts
+var Q = {
+  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."
+  }
+}, $ = Object.keys(Q);
+function S(e) {
+  let t = new Set(e);
+  return $.map((r) => Q[r]).filter((r) => !r.plugin || t.has(r.plugin));
+}
+function X(e) {
+  let t = e.path.replace(/^\/+|\/+$/g, "");
+  return t.length === 0 ? "index.ts" : `${t}/index.ts`;
+}
+// packages/cli/src/generators/routes.ts
+async function Z({ pluginIds: e, templateIds: t }) {
+  if (!e.includes("fs")) return [];
+  let r = S(e).filter((s) => t.includes(s.id));
+  return Promise.all(r.map(async (s) => ({
+    fileName: X(s),
+    content: await D(s.source)
+  })));
+}
+// packages/cli/src/helpers/git.ts
+import { execSync as v } from "child_process";
+import { rmSync as Ee } from "fs";
+import { join as Se } from "path";
+function Ae(e) {
+  try {
+    return v("git rev-parse --is-inside-work-tree", { cwd: e, stdio: "ignore" }), !0;
+  } catch {
+    return !1;
+  }
+}
+function Re(e) {
+  try {
+    return v("git config init.defaultBranch", { cwd: e, stdio: "ignore" }), !0;
+  } catch {
+    return !1;
+  }
+}
+function ee(e) {
+  let t = !1;
+  try {
+    return v("git --version", { stdio: "ignore" }), Ae(e) ? !1 : (v("git init", { cwd: e, stdio: "ignore" }), t = !0, Re(e) || v("git checkout -b main", { cwd: e, stdio: "ignore" }), v("git add -A", { cwd: e, stdio: "ignore" }), v('git commit -m "Initial commit from create-asterflow-app"', { cwd: e, stdio: "ignore" }), !0);
+  } catch {
+    if (t)
+      try {
+        Ee(Se(e, ".git"), { recursive: !0, force: !0 });
+      } catch {
+      }
+    return !1;
+  }
+}
+// packages/cli/src/helpers/isFolderEmpty.ts
+import { lstatSync as Ne, readdirSync as Te } from "fs";
+import { join as Ce } from "path";
+import te from "chalk";
+var De =  new Set([
+  ".DS_Store",
+  ".git",
+  ".gitattributes",
+  ".gitignore",
+  ".gitlab-ci.yml",
+  ".hg",
+  ".hgcheck",
+  ".hgignore",
+  ".idea",
+  ".npmignore",
+  ".vscode",
+  "LICENSE",
+  "Thumbs.db"
+]);
+function re(e, t) {
+  let r = Te(e).filter((s) => !De.has(s) && !s.endsWith(".iml"));
+  if (r.length === 0) return !0;
+  console.log(`The directory ${te.green(t)} contains files that could conflict:`), console.log();
+  for (let s of r) {
+    let l = Ne(Ce(e, s)).isDirectory();
+    console.log(`  ${te.cyan(s)}${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
+import { constants as Oe } from "fs";
+import { access as Fe } from "fs/promises";
+async function ne(e) {
+  try {
+    return await Fe(e, Oe.W_OK), !0;
+  } catch {
+    return !1;
+  }
+}
+// packages/cli/src/helpers/validateProjectName.ts
+import Me from "validate-npm-package-name";
+function F(e) {
+  let t = Me(e);
+  return t.validForNewPackages ? { valid: !0 } : {
+    valid: !1,
+    problems: [...t.errors ?? [], ...t.warnings ?? []]
+  };
+}
+// packages/cli/src/registry/adapters.ts
+var j = {
+  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:
+  })`
+  }
+}, I = Object.keys(j);
+// packages/cli/src/commands/init.ts
+var Be = Ue(_e), k = {
+  adapter: "bun",
+  plugins: ["fs", "multipart"],
+  install: !0,
+  git: !0
+};
+async function se(e) {
+  i.intro("Create a new AsterFlow project");
+  let t = Le(e.directory ?? "."), r = _(t) === "." ? "my-asterflow-app" : _(t);
+  if (!await ne(oe(t))) {
+    i.cancel(`The path ${t} is not writable. Check folder permissions and try again.`), process.exitCode = 1;
+    return;
+  }
+  if (await A(t, { recursive: !0 }), !re(t, _(t))) {
+    process.exitCode = 1;
+    return;
+  }
+  let s = process.argv.some((n) => n.startsWith("--")), l = ie.isCI || !!e.yes || s, b = s && !e.yes && !ie.isCI;
+  if (e.name) {
+    let n = F(e.name);
+    if (!n.valid) {
+      i.cancel(`Invalid project name "${e.name}":
+${n.problems.map((o) => `  - ${o}`).join(`
+`)}`), process.exitCode = 1;
+      return;
+    }
+  }
+  let m = e.name;
+  if (m === void 0)
+    if (l)
+      m = r;
+    else {
+      let n = await i.text({
+        message: "Project name",
+        placeholder: r,
+        defaultValue: r,
+        validate: (o) => {
+          let g = F(o || r);
+          return g.valid ? void 0 : `Invalid project name: ${g.problems[0]}`;
+        }
+      });
+      if (i.isCancel(n)) return i.cancel("Cancelled.");
+      m = n;
+    }
+  if (e.adapter && !j[e.adapter]) {
+    i.cancel(`Unknown adapter "${e.adapter}". Available: ${I.join(", ")}`), process.exitCode = 1;
+    return;
+  }
+  let p = e.adapter;
+  if (!p)
+    if (l)
+      p = k.adapter;
+    else {
+      let n = await i.select({
+        message: "Which adapter do you want to use?",
+        options: Object.values(j).map((o) => ({ value: o.id, label: o.label })),
+        initialValue: k.adapter
+      });
+      if (i.isCancel(n)) return i.cancel("Cancelled.");
+      p = n;
+    }
+  let c;
+  if (e.plugins !== void 0) {
+    c = e.plugins.split(",").map((o) => o.trim()).filter(Boolean);
+    let n = c.filter((o) => !y[o]);
+    if (n.length > 0) {
+      i.cancel(`Unknown plugin${n.length > 1 ? "s" : ""}: ${n.join(", ")}. Available: ${Object.keys(y).join(", ")}`), process.exitCode = 1;
+      return;
+    }
+  } else if (l)
+    c = k.plugins;
+  else {
+    let n = await i.multiselect({
+      message: "Which plugins do you want to install? (space to select, enter to confirm)",
+      options: Object.values(y).map((o) => ({ value: o.id, label: o.packageName, hint: o.description })),
+      initialValues: k.plugins,
+      required: !1
+    });
+    if (i.isCancel(n)) return i.cancel("Cancelled.");
+    c = n;
+  }
+  c.length === 0 && (c = k.plugins);
+  let u = S(c), f;
+  if (e.routes !== void 0) {
+    let n = e.routes.split(",").map((g) => g.trim()).filter(Boolean);
+    f = n.includes("none") ? [] : n;
+    let o = f.filter((g) => !u.some((le) => le.id === g));
+    if (o.length > 0) {
+      i.cancel(`Unknown route template${o.length > 1 ? "s" : ""}: ${o.join(", ")}. Available: ${u.map((g) => g.id).join(", ")}`), process.exitCode = 1;
+      return;
+    }
+  } else if (l)
+    f = u.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: u.map((o) => ({ value: o.id, label: o.path, hint: o.summary })),
+      initialValues: u.map((o) => o.id),
+      required: !1
+    });
+    if (i.isCancel(n)) return i.cancel("Cancelled.");
+    f = n;
+  }
+  let a = e.install;
+  if (a === void 0)
+    if (l)
+      a = k.install;
+    else {
+      let n = await i.confirm({ message: "Install dependencies now?", initialValue: k.install });
+      if (i.isCancel(n)) return i.cancel("Cancelled.");
+      a = n;
+    }
+  let h = e.git;
+  if (h === void 0)
+    if (l)
+      h = k.git;
+    else {
+      let n = await i.confirm({ message: "Initialize a git repository?", initialValue: k.git });
+      if (i.isCancel(n)) return i.cancel("Cancelled.");
+      h = n;
+    }
+  b && 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: f, install: a, git: h });
+  let w = j[p], E = c.map((n) => y[n]), G = i.spinner();
+  G.start("Scaffolding project");
+  let N = x(t, "src");
+  await A(N, { recursive: !0 }), await M(x(t, "package.json"), K({ name: m, adapter: w, plugins: E })), await O("tsconfig.json", x(t, "tsconfig.json")), await M(x(N, "index.ts"), q({ adapter: w, plugins: E, stub: f.length > 0 })), await O("gitignore", x(t, ".gitignore")), E.some((n) => n.id === "fs") && await Ge(x(t, ".gitignore"), `src/routes.gen.ts
+`);
+  let L = await Z({ pluginIds: c, templateIds: f });
+  if (L.length > 0) {
+    let n = x(N, "routes");
+    await A(n, { recursive: !0 });
+    for (let o of L) {
+      let g = x(n, o.fileName);
+      await A(oe(g), { recursive: !0 }), await M(g, o.content);
+    }
+  }
+  G.stop("Project scaffolded");
+  let T = U(e.packageManager, t);
+  if (a) {
+    let n = B(T), o = i.spinner();
+    o.start(`Installing dependencies (${n})`);
+    try {
+      await Be(n, { cwd: t }), o.stop("Dependencies installed");
+    } catch (g) {
+      o.stop("Failed to install dependencies"), i.log.error(g instanceof Error ? g.message : String(g));
+    }
+  }
+  h && ee(t) && i.log.success("Initialized a git repository.");
+  for (let n of E)
+    i.log.info(`${n.packageName}: ${n.usageNote}`);
+  Ye({ name: m, targetDir: t, packageManager: T, useYarn: T === "yarn" });
+}
+function We(e, t) {
+  let r = [];
+  e.adapter && r.push(`  --adapter <id>   ${t.adapterId}  (available: ${I.join(", ")})`), e.plugins && r.push(`  --plugins <ids>  ${t.pluginIds.length > 0 ? t.pluginIds.join(",") : "none"}  (available: ${Object.keys(y).join(", ")})`), e.routes && r.push(`  --routes <ids>   ${t.templateIds.length > 0 ? t.templateIds.join(",") : "none"}  (available: ${$.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: s }) {
+  let l = `${r} ${s ? "" : "run "}dev`;
+  i.note(`cd ${t}
+${l}`, "Next steps"), i.outro(`Success! Created ${e} at ${t}`);
+}
+// packages/cli/src/commands/list.ts
+import R from "chalk";
+function ae() {
+  console.log(R.bold(`
+Available AsterFlow plugins:
+`));
+  for (let e of Object.values(y))
+    console.log(`  ${R.cyan(e.id.padEnd(12))} ${R.gray(e.packageName)}`), console.log(`  ${" ".repeat(12)} ${e.description}
+`);
+  console.log(R.gray(`Install with: asterflow add <name>[,<name>...]
+`));
+}
+// packages/cli/src/index.ts
+(async () => {
+  await Ve(ze(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 (${I.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" (${$.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 se({
+        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 Y({ names: e.names, directory: e.directory });
+    }
+  ).command(
+    "list",
+    "List available plugins",
+    () => {
+    },
+    () => ae()
+  ).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 J({ 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/mjs/package.json

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

package/dist/types/commands/add.d.ts

@@ -0,0 +1,5 @@
+export interface AddOptions {
+    names: string;
+    directory?: string;
+}
+export declare function runAdd({ names, directory }: AddOptions): Promise<void>;

package/dist/types/commands/generate.d.ts

@@ -0,0 +1,6 @@
+export interface GenerateOptions {
+    directory?: string;
+    out?: string;
+    watch?: boolean;
+}
+export declare function runGenerate({ directory, out, watch: watchMode }: GenerateOptions): Promise<void>;

package/dist/types/commands/init.d.ts

@@ -0,0 +1,16 @@
+import type { PackageManager } from '../utils/packageManager';
+export interface InitOptions {
+    directory?: string;
+    name?: string;
+    adapter?: string;
+    /** Comma-separated plugin ids, e.g. "fs,multipart" - same style as `asterflow add`. */
+    plugins?: string;
+    /** Comma-separated route template ids, e.g. "hello,upload", or "none" - same style as `plugins`. */
+    routes?: string;
+    install?: boolean;
+    git?: boolean;
+    packageManager?: PackageManager;
+    /** Accept defaults for anything not explicitly set, without prompting - even with zero other flags. */
+    yes?: boolean;
+}
+export declare function runInit(options: InitOptions): Promise<void>;

package/dist/types/commands/list.d.ts

@@ -0,0 +1 @@
+export declare function runList(): void;

package/dist/types/generators/appEntry.d.ts

@@ -0,0 +1,8 @@
+import type { AdapterDefinition } from '../registry/adapters';
+import type { PluginDefinition } from '../registry/plugins';
+export interface AppEntryOptions {
+    adapter: AdapterDefinition;
+    plugins: PluginDefinition[];
+    stub: boolean;
+}
+export declare function generateEntry({ adapter, plugins, stub }: AppEntryOptions): string;