@velajs/cli 0.3.1 → 0.3.2

package/dist/config.d.ts

@@ -1,4 +1,5 @@
-import type { Type, VelaApplication } from '@velajs/vela';
+import { Type, VelaApplication } from "@velajs/vela";
+//#region src/config.d.ts
 /**
  * A `vela.config.{js,mjs,ts}` default-exports (or exports `config`) this shape.
  * You wire your runtime bindings inside `createApp` — e.g. via miniflare for a
@@ -15,19 +16,22 @@ import type { Type, VelaApplication } from '@velajs/vela';
  * });
  * ```
  */
-export interface VelaConfig {
-    createApp(): Promise<VelaApplication> | VelaApplication;
-    /**
-     * The app's root module class — needed only by commands that work from
-     * module metadata rather than the built app (`vela openapi dump`).
-     */
-    rootModule?: Type;
+interface VelaConfig {
+  createApp(): Promise<VelaApplication> | VelaApplication;
+  /**
+   * The app's root module class — needed only by commands that work from
+   * module metadata rather than the built app (`vela openapi dump`).
+   */
+  rootModule?: Type;
 }
 /** Identity helper for type-safe config files. */
-export declare function defineVelaConfig(config: VelaConfig): VelaConfig;
+declare function defineVelaConfig(config: VelaConfig): VelaConfig;
 /**
  * Locate + import the vela config. `.ts` requires a runtime that strips types
  * (Node 22+ `--experimental-strip-types`, or tsx/ts-node); `.js`/`.mjs` load
  * directly.
  */
-export declare function loadConfig(cwd?: string, explicitPath?: string): Promise<VelaConfig>;
+declare function loadConfig(cwd?: string, explicitPath?: string): Promise<VelaConfig>;
+//#endregion
+export { VelaConfig, defineVelaConfig, loadConfig };
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -1,42 +1,39 @@
-import { access } from 'node:fs/promises';
-import { isAbsolute, join, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { access } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/config.ts
 /** Identity helper for type-safe config files. */
-export function defineVelaConfig(config) {
-    return config;
+function defineVelaConfig(config) {
+	return config;
 }
-const CANDIDATES = ['vela.config.js', 'vela.config.mjs', 'vela.config.ts'];
+const CANDIDATES = [
+	"vela.config.js",
+	"vela.config.mjs",
+	"vela.config.ts"
+];
 /**
- * Locate + import the vela config. `.ts` requires a runtime that strips types
- * (Node 22+ `--experimental-strip-types`, or tsx/ts-node); `.js`/`.mjs` load
- * directly.
- */
-export async function loadConfig(cwd = process.cwd(), explicitPath) {
-    const path = explicitPath
-        ? isAbsolute(explicitPath)
-            ? explicitPath
-            : resolve(cwd, explicitPath)
-        : await findConfig(cwd);
-    if (!path) {
-        throw new Error(`No vela config found. Create one of: ${CANDIDATES.join(', ')} (or pass --config <path>).`);
-    }
-    const mod = (await import(pathToFileURL(path).href));
-    const config = mod.default ?? mod.config;
-    if (!config || typeof config.createApp !== 'function') {
-        throw new Error(`Config at ${path} must export { createApp(): Promise<VelaApplication> } (default export or a named 'config').`);
-    }
-    return config;
+* Locate + import the vela config. `.ts` requires a runtime that strips types
+* (Node 22+ `--experimental-strip-types`, or tsx/ts-node); `.js`/`.mjs` load
+* directly.
+*/
+async function loadConfig(cwd = process.cwd(), explicitPath) {
+	const path = explicitPath ? isAbsolute(explicitPath) ? explicitPath : resolve(cwd, explicitPath) : await findConfig(cwd);
+	if (!path) throw new Error(`No vela config found. Create one of: ${CANDIDATES.join(", ")} (or pass --config <path>).`);
+	const mod = await import(pathToFileURL(path).href);
+	const config = mod.default ?? mod.config;
+	if (!config || typeof config.createApp !== "function") throw new Error(`Config at ${path} must export { createApp(): Promise<VelaApplication> } (default export or a named 'config').`);
+	return config;
 }
 async function findConfig(cwd) {
-    for (const name of CANDIDATES) {
-        const candidate = join(cwd, name);
-        try {
-            await access(candidate);
-            return candidate;
-        }
-        catch {
-            // try next
-        }
-    }
-    return undefined;
+	for (const name of CANDIDATES) {
+		const candidate = join(cwd, name);
+		try {
+			await access(candidate);
+			return candidate;
+		} catch {}
+	}
 }
+//#endregion
+export { defineVelaConfig, loadConfig };
+
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":[],"sources":["../src/config.ts"],"sourcesContent":["import { access } from 'node:fs/promises';\nimport { isAbsolute, join, resolve } from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport type { Type, VelaApplication } from '@velajs/vela';\n\n/**\n * A `vela.config.{js,mjs,ts}` default-exports (or exports `config`) this shape.\n * You wire your runtime bindings inside `createApp` — e.g. via miniflare for a\n * Cloudflare Worker, or a plain Node adapter — and return a built app.\n *\n * ```ts\n * // vela.config.ts\n * import { defineVelaConfig } from '@velajs/cli/config';\n * export default defineVelaConfig({\n *   async createApp() {\n *     const { createCloudflareApp } = await import('@velajs/cloudflare');\n *     return createCloudflareApp(AppModule);\n *   },\n * });\n * ```\n */\nexport interface VelaConfig {\n  createApp(): Promise<VelaApplication> | VelaApplication;\n  /**\n   * The app's root module class — needed only by commands that work from\n   * module metadata rather than the built app (`vela openapi dump`).\n   */\n  rootModule?: Type;\n}\n\n/** Identity helper for type-safe config files. */\nexport function defineVelaConfig(config: VelaConfig): VelaConfig {\n  return config;\n}\n\nconst CANDIDATES = ['vela.config.js', 'vela.config.mjs', 'vela.config.ts'];\n\n/**\n * Locate + import the vela config. `.ts` requires a runtime that strips types\n * (Node 22+ `--experimental-strip-types`, or tsx/ts-node); `.js`/`.mjs` load\n * directly.\n */\nexport async function loadConfig(\n  cwd: string = process.cwd(),\n  explicitPath?: string,\n): Promise<VelaConfig> {\n  const path = explicitPath\n    ? isAbsolute(explicitPath)\n      ? explicitPath\n      : resolve(cwd, explicitPath)\n    : await findConfig(cwd);\n\n  if (!path) {\n    throw new Error(\n      `No vela config found. Create one of: ${CANDIDATES.join(', ')} (or pass --config <path>).`,\n    );\n  }\n\n  const mod = (await import(pathToFileURL(path).href)) as {\n    default?: VelaConfig;\n    config?: VelaConfig;\n  };\n  const config = mod.default ?? mod.config;\n  if (!config || typeof config.createApp !== 'function') {\n    throw new Error(\n      `Config at ${path} must export { createApp(): Promise<VelaApplication> } (default export or a named 'config').`,\n    );\n  }\n  return config;\n}\n\nasync function findConfig(cwd: string): Promise<string | undefined> {\n  for (const name of CANDIDATES) {\n    const candidate = join(cwd, name);\n    try {\n      await access(candidate);\n      return candidate;\n    } catch {\n      // try next\n    }\n  }\n  return undefined;\n}\n"],"mappings":";;;;;AA+BA,SAAgB,iBAAiB,QAAgC;CAC/D,OAAO;AACT;AAEA,MAAM,aAAa;CAAC;CAAkB;CAAmB;AAAgB;;;;;;AAOzE,eAAsB,WACpB,MAAc,QAAQ,IAAI,GAC1B,cACqB;CACrB,MAAM,OAAO,eACT,WAAW,YAAY,IACrB,eACA,QAAQ,KAAK,YAAY,IAC3B,MAAM,WAAW,GAAG;CAExB,IAAI,CAAC,MACH,MAAM,IAAI,MACR,wCAAwC,WAAW,KAAK,IAAI,EAAE,4BAChE;CAGF,MAAM,MAAO,MAAM,OAAO,cAAc,IAAI,CAAC,CAAC;CAI9C,MAAM,SAAS,IAAI,WAAW,IAAI;CAClC,IAAI,CAAC,UAAU,OAAO,OAAO,cAAc,YACzC,MAAM,IAAI,MACR,aAAa,KAAK,6FACpB;CAEF,OAAO;AACT;AAEA,eAAe,WAAW,KAA0C;CAClE,KAAK,MAAM,QAAQ,YAAY;EAC7B,MAAM,YAAY,KAAK,KAAK,IAAI;EAChC,IAAI;GACF,MAAM,OAAO,SAAS;GACtB,OAAO;EACT,QAAQ,CAER;CACF;AAEF"}

package/dist/index.d.ts

@@ -1,10 +1,114 @@
-#!/usr/bin/env node
-export { SeedCommand } from './commands/seed.command.js';
-export { EntrypointListCommand, ModuleGraphCommand, OpenApiDumpCommand, RouteListCommand, } from './commands/introspect.commands.js';
-export { McpServeCommand } from './commands/mcp.command.js';
-export { collectRoutes, collectModules, collectEntrypoints, renderModuleTree } from './introspect.js';
-export type { RouteRow, EntrypointRow } from './introspect.js';
-export { renderTable } from './format.js';
-export { loadConfig, defineVelaConfig } from './config.js';
-export type { VelaConfig } from './config.js';
-export { formatSeedResults } from './format.js';
+import { VelaConfig, defineVelaConfig, loadConfig } from "./config.js";
+import { Command } from "clipanion";
+import { ModuleDescription, VelaApplication } from "@velajs/vela";
+import { SeederResult } from "@velajs/vela/seeder";
+//#region src/commands/seed.command.d.ts
+/** `vela db seed` — build the app from vela.config and run its seeders. */
+declare class SeedCommand extends Command {
+  static paths: string[][];
+  static usage: import("clipanion").Usage;
+  config: string | undefined;
+  continueOnError: boolean;
+  execute(): Promise<number>;
+}
+//#endregion
+//#region src/commands/introspect.commands.d.ts
+/** Shared shell: load config → createApp → run → best-effort dispose. */
+declare abstract class AppCommand extends Command {
+  config: string | undefined;
+  json: boolean;
+  protected abstract run(app: VelaApplication): Promise<number>;
+  execute(): Promise<number>;
+  protected print(text: string): void;
+}
+/** `vela route list` — the app's HTTP route table. */
+declare class RouteListCommand extends AppCommand {
+  static paths: string[][];
+  static usage: import("clipanion").Usage;
+  protected run(app: VelaApplication): Promise<number>;
+}
+/** `vela module graph` — the loaded module graph. */
+declare class ModuleGraphCommand extends AppCommand {
+  static paths: string[][];
+  static usage: import("clipanion").Usage;
+  protected run(app: VelaApplication): Promise<number>;
+}
+/** `vela entrypoint list` — declared entrypoint kinds and their entries. */
+declare class EntrypointListCommand extends AppCommand {
+  static paths: string[][];
+  static usage: import("clipanion").Usage;
+  protected run(app: VelaApplication): Promise<number>;
+}
+/** `vela openapi dump` — emit the OpenAPI document. */
+declare class OpenApiDumpCommand extends Command {
+  static paths: string[][];
+  static usage: import("clipanion").Usage;
+  config: string | undefined;
+  out: string | undefined;
+  title: string | undefined;
+  apiVersion: string | undefined;
+  globalPrefix: string | undefined;
+  execute(): Promise<number>;
+}
+//#endregion
+//#region src/commands/mcp.command.d.ts
+/**
+ * `vela mcp serve` — an MCP stdio server exposing the same READ-ONLY
+ * introspection as the `route`/`module`/`entrypoint`/`openapi` commands, so an
+ * AI agent can query a Vela app's shape over the Model Context Protocol.
+ *
+ * Deliberately does NOT extend `AppCommand`: that base disposes the app in its
+ * `finally` the moment `run()` returns, but an MCP server must stay alive until
+ * the transport closes. stdout is reserved for JSON-RPC framing; every human
+ * message goes to stderr.
+ */
+declare class McpServeCommand extends Command {
+  static paths: string[][];
+  static usage: import("clipanion").Usage;
+  config: string | undefined;
+  execute(): Promise<number>;
+}
+//#endregion
+//#region src/introspect.d.ts
+/** One row of `vela route list`. */
+interface RouteRow {
+  method: string;
+  path: string;
+  /** `Controller#handler`, or `(mounted)` for routes vela did not compose
+   * itself (RouteContributor/CRUD, OpenAPI UI mounts, manual Hono routes). */
+  handler: string;
+  source: 'controller' | 'mounted';
+}
+/**
+ * The app's route table: `describeRoutes()` rows (framework-composed truth)
+ * plus everything else present on the Hono router, deduped and labeled
+ * `(mounted)`. Returns null when the app never built HTTP routes.
+ */
+declare function collectRoutes(app: VelaApplication): RouteRow[] | null;
+/** `vela module graph` tree lines (or raw descriptions for --json). */
+declare function collectModules(app: VelaApplication): ModuleDescription[];
+declare function renderModuleTree(modules: ModuleDescription[]): string[];
+/** One row of `vela entrypoint list`. */
+interface EntrypointRow {
+  kind: string;
+  target: string;
+  meta: string;
+}
+/**
+ * Every DECLARED entrypoint kind (from the global kind store — includes kinds
+ * with zero entries) joined with the app's entries. Metadata-only entries of
+ * lazy modules list fine; nothing materializes.
+ */
+declare function collectEntrypoints(app: VelaApplication): EntrypointRow[];
+//#endregion
+//#region src/format.d.ts
+/**
+ * Render seeder results to a logger and return a process exit code
+ * (0 = all ran, 1 = at least one failed). Pure — no I/O beyond the logger.
+ */
+declare function formatSeedResults(results: SeederResult[], log?: (message: string) => void): number;
+/** Aligned plain-text table. Pure; returns lines. */
+declare function renderTable(headers: string[], rows: string[][]): string[];
+//#endregion
+export { EntrypointListCommand, type EntrypointRow, McpServeCommand, ModuleGraphCommand, OpenApiDumpCommand, RouteListCommand, type RouteRow, SeedCommand, type VelaConfig, collectEntrypoints, collectModules, collectRoutes, defineVelaConfig, formatSeedResults, loadConfig, renderModuleTree, renderTable };
+//# sourceMappingURL=index.d.ts.map