@adhd/apigen-cli 0.1.0 → 0.1.1

package/lib/commands/generate-registry.d.ts

@@ -1,4 +1,4 @@
-import { OutputPlugin } from '@adhd/apigen-core';
+import { OutputPlugin } from '@adhd/apigen-core-client';
 import { Command } from 'commander';
 
 export declare function registerGenerateRegistryCommand(program: Command, plugins: Record<string, OutputPlugin>): void;

package/lib/commands/generate.d.ts

@@ -1,6 +1,47 @@
-import { ExportMode, OutputPlugin } from '@adhd/apigen-core';
+import { ExportMode, OutputPlugin, ComposedSchemas } from '@adhd/apigen-core-client';
 import { Command } from 'commander';
 
+/**
+ * Recursively walk a JSON-Schema node (any depth) and collect every
+ * unique `format` string value found anywhere in the tree.
+ *
+ * Pure function: no I/O, no mutation of the input.
+ *
+ * @param node  Any JSON value (Schema node, array, primitive).
+ * @param seen  Cycle guard — the set of objects already visited (prevents
+ *              infinite loops on schemas with `definitions` back-refs).
+ * @returns     A `Set<string>` of all format strings found.
+ */
+export declare function collectFormats(node: unknown, seen?: WeakSet<object>): Set<string>;
+/**
+ * Given a surface's `ComposedSchemas`, return the npm dependency entries
+ * required to support the logical types actually used by its operations.
+ *
+ * Walks every input + output schema, unions their `format` annotations,
+ * looks each up in the authoritative {@link tsDepMap} from `@adhd/apigen-base-logical`,
+ * and returns a `Record<name, version>` suitable for merging into `package.json`
+ * `dependencies`.
+ *
+ * A surface with NO rich types returns an empty record (no `decimal.js`,
+ * etc.). A surface using `Decimal` returns `{ 'decimal.js': '^10' }`.
+ *
+ * @param schemas The surface's composed schema map (fn-name → {input, output}).
+ */
+export declare function collectLogicalTypeDeps(schemas: ComposedSchemas | Record<string, {
+    input: Record<string, unknown>;
+    output: Record<string, unknown>;
+}>): Record<string, string>;
+/**
+ * Patch the generated `package.json` in `outputDir` by merging in
+ * `logicalTypeDeps`. When the `package.json` has no deps or the dep
+ * map is empty this is a no-op (safe to call unconditionally).
+ *
+ * Called AFTER {@link emitResolutionScaffolding} so the base deps
+ * (apigen-runtime, sdk) are already present.
+ *
+ * Exported for testing; the generate command is the normal caller.
+ */
+export declare function patchPackageJsonDeps(outputDir: string, logicalTypeDeps: Record<string, string>): void;
 /** Resolve the --export flag value to an ExportMode. */
 export declare function resolveExportMode(exportFlag: string | undefined): ExportMode;
 export declare function registerGenerateCommand(program: Command, plugins: Record<string, OutputPlugin>): void;

package/lib/commands/list-types.d.ts

@@ -0,0 +1,11 @@
+import { OutputPlugin } from '@adhd/apigen-core-client';
+import { Command } from 'commander';
+
+/**
+ * `apigen list-types` — the only discovery mechanism for valid `--type`
+ * values before FEAT-APIGEN-019 was reading source, hitting an error, or
+ * already knowing them. Output is derived live from the same `plugins` map
+ * every other command receives, so it can never drift from what's actually
+ * registered (see `../plugin-registry`).
+ */
+export declare function registerListTypesCommand(program: Command, plugins: Record<string, OutputPlugin>, write?: (text: string) => void): void;

package/lib/commands/run-registry.d.ts

@@ -1,4 +1,4 @@
-import { OutputPlugin } from '@adhd/apigen-core';
+import { OutputPlugin } from '@adhd/apigen-core-client';
 import { Command } from 'commander';
 
 export declare function registerRunRegistryCommand(program: Command, plugins: Record<string, OutputPlugin>): void;

package/lib/commands/run.d.ts

@@ -1,4 +1,49 @@
-import { OutputPlugin } from '@adhd/apigen-core';
 import { Command } from 'commander';
+import { ComposedSchemas, OutputPlugin, Plugin } from '@adhd/apigen-core-client';
 
+/**
+ * Assert that the function table built from the source module is non-empty.
+ *
+ * A source that yields 0 functions is almost certainly generated output, a
+ * type-only file, or the wrong path — not a callable apigen surface.  Failing
+ * here with an actionable message avoids the cryptic `ERR_MODULE_NOT_FOUND`
+ * crash that occurs later when the server tries to dispatch to a non-existent
+ * route.
+ *
+ * @param fns        - Function table produced by `buildFnTable`.
+ * @param sourceFile - Absolute path to the source, for the error message.
+ * @throws if `fns` contains no entries.
+ */
+export declare function assertFnsNonEmpty(fns: Record<string, (...args: unknown[]) => unknown>, sourceFile: string): void;
+/**
+ * A resolver function that mimics `require.resolve` for a package name.
+ * Injected in tests to simulate absence without actually removing packages.
+ */
+export type LibResolver = (pkg: string) => string;
+/**
+ * Assert that `decimal.js` is resolvable when any function in `schemas`
+ * uses a `format:'decimal'` parameter or return value.
+ *
+ * @param schemas  - The composed schemas for the surface.
+ * @param resolver - Optional resolver; defaults to `require.resolve`.
+ *                   Injected in tests to simulate the lib being absent.
+ * @throws if decimal-using functions are found but `decimal.js` cannot resolve.
+ */
+export declare function assertDecimalLibPresent(schemas: ComposedSchemas, resolver?: LibResolver): void;
+/**
+ * Resolve `--use` specifiers into loaded {@link Plugin} objects.
+ *
+ * Resolution order per specifier:
+ *   1. Built-in slug (`health`, `logger`) → the statically-imported plugin.
+ *   2. Otherwise treat the specifier as a package name or local path and
+ *      dynamically `import()` it (default or named `plugin`/`<id>Plugin` export).
+ *
+ * The loaded plugins are threaded to the run plugin via `options.usePlugins`
+ * so the transport adapter can compose their `layer`/`mount` capabilities
+ * (RunInput carries no dedicated field).
+ *
+ * @param specifiers - The raw `--use` values (slugs, package names, or paths).
+ * @returns The loaded plugin objects, in declaration order.
+ */
+export declare function loadUsePlugins(specifiers: string[]): Promise<Plugin[]>;
 export declare function registerRunCommand(program: Command, plugins: Record<string, OutputPlugin>): void;

package/lib/commands/serve.d.ts

@@ -0,0 +1,158 @@
+import { PluginLanguage } from '@adhd/apigen-core-client';
+import { ChildProcess } from 'node:child_process';
+import { Command } from 'commander';
+
+import * as http from 'node:http';
+/** A single mounted source: its namespace, language, plugin, file, and runtime. */
+export interface Host {
+    /** Namespace prefix this host serves under (`/<ns>/*`). */
+    namespace: string;
+    /** The host language (`ts` | `py` | …). */
+    language: PluginLanguage;
+    /** The plugin id driving the child (`api-fastify`, `py-flask`, `py-grpc`, …). */
+    plugin: string;
+    /** Absolute path to the source file. */
+    source: string;
+    /** Internal loopback port the child listens on. */
+    port: number;
+    /**
+     * Transport protocol for this host.
+     * - `'http'` — child is an HTTP/1.1 server (api-fastify, py-flask).
+     * - `'grpc'` — child is a gRPC (HTTP/2) server (py-grpc).
+     */
+    transport: 'http' | 'grpc';
+    /** The child process (set once spawned). */
+    child?: ChildProcess;
+    /** Liveness flag flipped to `false` when the child exits. */
+    alive: boolean;
+    /** Readiness flag flipped to `true` once the child is accepting connections. */
+    ready: boolean;
+}
+/** Per-host status in the aggregate `_meta/health` (§13.1). */
+export type HostHealthStatus = 'ready' | 'down';
+/**
+ * Parse `--mount <ns>=<plugin>` pairs into a `{ ns → plugin }` record.
+ *
+ * @throws if a pair is missing the `=` separator or has an empty side.
+ */
+export declare function parseMounts(pairs: string[]): Record<string, string>;
+/** Derive a source's default namespace: its filename stem. */
+export declare function namespaceOfSource(file: string): string;
+/**
+ * Resolve the {@link Host} descriptors (sans runtime fields) for the given
+ * `--source` list, applying any `--mount` overrides.
+ *
+ * Resolution per source:
+ *   1. `language = languageOfSource(file)` — unknown extension → error.
+ *   2. `namespace = stem(file)`.
+ *   3. `plugin = mounts[namespace] ?? DEFAULT_PLUGIN_FOR_LANGUAGE[language]`.
+ *   4. `transport = GRPC_PLUGINS.has(plugin) ? 'grpc' : 'http'`.
+ *
+ * @throws on an unknown extension, an unmappable language, or a duplicate
+ *         namespace (two sources would collide on the same `/<ns>/*` prefix).
+ */
+export declare function resolveHosts(sources: string[], mounts: Record<string, string>): Host[];
+/**
+ * Extract the leading path segment of a request URL (the namespace).
+ *
+ * `/users/getUser?x=1` → `users`; `/_meta/health` → `_meta`; `/` → `''`.
+ */
+export declare function namespaceFromUrl(url: string): string;
+/**
+ * Ask the OS for a free loopback TCP port by binding port 0 and reading back
+ * the assigned port, then releasing it.  There is an unavoidable TOCTOU window
+ * between release and the child binding it; in practice the child binds within
+ * milliseconds and the kernel does not immediately re-hand the same ephemeral
+ * port, so collisions are vanishingly rare.  Each host gets its own port.
+ */
+export declare function findFreePort(): Promise<number>;
+/**
+ * Poll an HTTP host's `_meta/health` until it answers 2xx or the deadline passes.
+ *
+ * Event-driven: it re-probes on a short interval, but each probe is a real HTTP
+ * round-trip to the child — readiness is the child *actually answering*, never
+ * a wall-clock sleep.  Aborts early (rejects) if the child exits first.
+ *
+ * @param host       - The host to probe.
+ * @param timeoutMs  - Overall budget (default 15 s — Python cold-start + import).
+ * @param intervalMs - Delay between probes (default 100 ms).
+ */
+export declare function waitForReady(host: Host, timeoutMs?: number, intervalMs?: number): Promise<void>;
+/**
+ * The path used to re-invoke this CLI for a child `run`.  When the CLI is the
+ * bundled standalone (`dist/.../index.js`), `process.argv[1]` is that bundle;
+ * spawning `node <bundle> run …` reuses the same inlined plugin graph.  Tests
+ * override this to point at a stub.
+ */
+export declare function selfCliPath(): string;
+/**
+ * Spawn one child `apigen run` for a HTTP host and wire its lifecycle.
+ *
+ * The child is started detached-free (same process group) so the front's
+ * teardown can signal it directly.  `alive` flips to `false` on exit; if a
+ * child dies, its `/<ns>/*` routes start returning 503 (partial availability).
+ *
+ * @param host       - The host to start (mutated: `child`, `alive`).
+ * @param cliPath    - Path to the apigen CLI entry to spawn (see {@link selfCliPath}).
+ * @param onExit     - Callback invoked when the child exits (for logging).
+ * @param extraArgs  - Extra args appended to the child `run` invocation (tests).
+ */
+export declare function spawnHost(host: Host, cliPath: string, onExit?: (host: Host, code: number | null, signal: NodeJS.Signals | null) => void, extraArgs?: string[]): ChildProcess;
+/**
+ * Kill every child process and resolve once all have exited (or the deadline
+ * passes, after which a hard `SIGKILL` is sent).  Idempotent.
+ *
+ * @param hosts      - The hosts whose children to terminate.
+ * @param graceMs    - Grace period before escalating SIGTERM → SIGKILL.
+ */
+export declare function killAll(hosts: Host[], graceMs?: number): Promise<void>;
+/**
+ * Build the aggregate `_meta/health` payload (§13.1).
+ *
+ * ```json
+ * { "status": "ok"|"degraded", "hosts": { "<ns>": "ready"|"down", … } }
+ * ```
+ *
+ * `status` is `ok` only when every host is ready; any down host → `degraded`
+ * (the front itself is still up — partial availability, never whole-surface
+ * down).
+ */
+export declare function aggregateHealth(hosts: Host[]): {
+    status: 'ok' | 'degraded';
+    hosts: Record<string, HostHealthStatus>;
+};
+/**
+ * Create the combined front server: HTTP/1.1 proxy + gRPC (HTTP/2) proxy,
+ * both on the same TCP port, disambiguated by inspecting the first bytes of
+ * each connection.
+ *
+ * @param hosts    - The resolved, spawned hosts (with live ports).
+ * @param frontPort - The TCP port the front should listen on.
+ */
+export declare function createFrontServer(hosts: Host[]): http.Server;
+/**
+ * Start the full serve stack: spawn every host, await readiness, then start the
+ * front.  Resolves to a teardown function and the listening front server.
+ *
+ * Exported (not just inlined in the action) so the behavioural test can drive
+ * the real stack in-process with bounded waits.
+ *
+ * @param opts.sources - The `--source` files.
+ * @param opts.port    - The front port.
+ * @param opts.mounts  - `{ ns → plugin }` overrides.
+ * @param opts.cliPath - The CLI entry to spawn children with (defaults to self).
+ * @param opts.log     - Optional logger sink (defaults to console.error).
+ */
+export declare function startServe(opts: {
+    sources: string[];
+    port: number;
+    mounts?: Record<string, string>;
+    cliPath?: string;
+    log?: (msg: string) => void;
+}): Promise<{
+    hosts: Host[];
+    front: http.Server;
+    shutdown: () => Promise<void>;
+}>;
+/** Register the `serve` command on the program. */
+export declare function registerServeCommand(program: Command): void;

package/lib/import-source.d.ts

@@ -1,8 +1,19 @@
 /**
- * Dynamically import a (possibly TypeScript) source module, registering the tsx
- * ESM loader for the duration of the import so that `.ts` entry files resolve in
- * a plain `node` process. The loader is unregistered afterward so no global hook
- * leaks into the rest of the run.
+ * Dynamically import a (possibly TypeScript) source module, registering both the
+ * tsx ESM loader and the tsx CJS `require` patch for the duration of the import so
+ * that `.ts` entry files resolve in a plain `node` process. Both loaders are
+ * unregistered afterward so no global hook leaks into the rest of the run.
+ *
+ * Both hooks are required, not just the ESM one: when the target (or a package it
+ * imports) has no `"type": "module"` in its nearest package.json — as internal
+ * workspace libs commonly don't — Node's ESM loader detects the `.ts` file as
+ * CommonJS and routes it through the CJS translator, which drives real
+ * `require()` calls for every relative import. Those requires use Node's classic
+ * CJS resolver, not the ESM resolve hook, so a source written with the
+ * NodeNext-style `./db.js` specifier (resolving to `./db.ts` on disk) fails with
+ * `MODULE_NOT_FOUND` unless `tsx/cjs/api` has also patched CJS resolution.
+ * Registering only `tsx/esm/api` reproduces exactly this failure; the full `tsx`
+ * CLI works because it patches both loaders — this mirrors that.
  *
  * Under a transpiling test runner (vitest) tsx registration is a harmless no-op,
  * so this same path works in-repo and standalone.

package/lib/logging.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '@adhd/apigen-runtime';
+import { Logger } from '@adhd/apigen-engine-runtime';
 import { Command } from 'commander';
 
 export interface LoggingFlags {

package/lib/orchestrator.d.ts

@@ -1,5 +1,5 @@
 import { ProjectionConfig } from '@adhd/apigen-naming';
-import { Operation, Descriptor, ComposedSchemas, ExportMode, Logger, OutputPlugin } from '@adhd/apigen-core';
+import { Operation, Descriptor, ComposedSchemas, ExportMode, Logger, OutputPlugin } from '@adhd/apigen-core-client';
 
 /**
  * A single source entry passed to the orchestrator.
@@ -12,9 +12,20 @@ export interface SourceEntry {
     /** Absolute path to the source file. */
     file: string;
     /**
-     * Export mode for this source. Defaults to `{ type: 'named' }` when omitted.
-     * Per-source because a single `run` may compose multiple differently-shaped
-     * sources.
+     * Export mode for this source — scopes which of the fully-extracted
+     * operations are actually composed into `packageSchemas` / served
+     * (BUG-APIGEN-034 fix). v2's `extract()` walks the FULL export-shape
+     * matrix (named, default, named-object, CJS — see extract.ts's header
+     * comment) unconditionally in a single pass, unlike v1's three
+     * mutually-exclusive extractors (`extractNamed`/`extractDefault`/
+     * `extractNamedObject`); `buildDescriptor()`'s Step 5 restores the same
+     * effective scoping by reclassifying each `Operation` by its `path` shape
+     * (see `opMatchesExportMode()`) rather than by re-running a separate
+     * extraction pass. Does NOT affect `descriptor.operations` (collision
+     * check, `--use` mount plugins) — only the served surface — matching v1's
+     * own behaviour where the collision-check step never respected
+     * `exportMode` either. Omitted → no scoping (all extracted operations are
+     * served); this is what `generate-registry`/`run-registry` rely on today.
      */
     exportMode?: ExportMode;
     /**
@@ -24,15 +35,25 @@ export interface SourceEntry {
     namespace?: string;
     /** Explicit tsconfig.json path.  Resolved per source file when omitted. */
     tsconfig?: string;
+    /**
+     * Import specifier written into generated code for this source, e.g. an
+     * npm package name (`'@adhd/foo'`) instead of the absolute extraction
+     * path. Defaults to `file` when omitted — true for the single-source
+     * `generate`/`run` CLI commands, where the resolved source path IS the
+     * import path. `generate-registry`/`run-registry` set this explicitly:
+     * their package discovery resolves a physical entry file for extraction
+     * (`file`) that differs from the package's published import specifier.
+     */
+    importPath?: string;
 }
 /**
  * Projection-override config (Tenet 1).
  *
  * Accepted from `--opt http.verb.<id>=GET` pairs or an `apigen.config` file.
  * Overrides are NEVER written to source.
+ * Extend here as other projection dimensions are added (route, name, …).
  */
-export interface OverrideConfig extends ProjectionConfig {
-}
+export type OverrideConfig = ProjectionConfig;
 /** Options passed to the v2 orchestrator. */
 export interface OrchestratorOptions {
     /** Source files to extract and merge.  Must be non-empty. */
@@ -106,6 +127,42 @@ export declare function loadOverrideConfig(configPath: string | undefined, cliOv
  * @param perSourceOps - Arrays produced by {@link extractSource} per file.
  */
 export declare function mergeOperations(perSourceOps: Operation[][]): Operation[];
+/**
+ * BUG-APIGEN-034: restores v1's `--export <mode>` scoping of the SERVED
+ * surface. v1 ran exactly one of three mutually-exclusive extractors
+ * (`extractNamed`/`extractDefault`/`extractNamedObject`) per `exportMode`;
+ * v2's `extract()` walks the full export-shape matrix unconditionally (see
+ * extract.ts's header comment), so this reclassifies each already-extracted
+ * `Operation` by `path` shape and filters Step 5's schema composition only —
+ * `descriptor.operations` (collision-check, `--use` mount plugins) stays
+ * unscoped, matching pre-v1-retirement behaviour (the old collision-check
+ * step never respected `exportMode` either — only what actually got SERVED
+ * did).
+ *
+ * Path-shape correspondence (extract.ts's six-shape matrix):
+ *   - `'named'`       → `path.length === 2` (shapes 1/2: a plain named
+ *     function/const export). This shape is also produced by shape 6 (a CJS
+ *     `module.exports` property) and shape 4's bare
+ *     `export default function foo(){}` form — neither is distinguishable
+ *     from a plain named export via `path` alone, since `Operation` carries
+ *     no export-shape discriminator (that would require extending
+ *     `extract()`/`Operation` itself — out of scope here, filed as a
+ *     follow-up). v1 never supported CJS sources or a bare default-fn-decl
+ *     under ANY `--export` mode (see extract.ts's shape 4/6 comments), so
+ *     folding them into `'named'` is a strict superset of v1's true
+ *     `extractNamed` coverage, never a subset: nothing v1 used to serve
+ *     under `--export` (omitted) goes missing here.
+ *   - `'default'`     → `path.length === 3 && path[1].raw === 'default'`
+ *     (shape 4's default-OBJECT branch only, e.g. `export default { a, b }`).
+ *     v1's `extractDefault` covered EXCLUSIVELY this object-literal
+ *     default-export form — never a bare `export default function foo(){}`
+ *     (shape 4's fn-decl branch) or an anonymous default fn (shape 5), both
+ *     new in v2 with no v1 predecessor — so excluding them here matches v1's
+ *     actual historical coverage exactly.
+ *   - `'named-object'` → `path.length === 3 && path[1].raw === mode.name`
+ *     (shape 3: `export const <mode.name> = { ... }`).
+ */
+export declare function opMatchesExportMode(op: Operation, mode: ExportMode): boolean;
 /**
  * Build the unified `OrchestratorDescriptor` from a set of source entries.
  *
@@ -114,7 +171,11 @@ export declare function mergeOperations(perSourceOps: Operation[][]): Operation[
  *   2. Extract canonical `Operation[]` per source (v2 extract).
  *   3. Merge into one list.
  *   4. Run the collision check (SPEC §5 uniqueness invariant).
- *   5. Build per-source `ComposedSchemas` for the v1 plugin surface.
+ *   5. Derive per-source `ComposedSchemas` (the plugin-facing surface every
+ *      `OutputPlugin.generate()`/`run()` actually dispatches against) FROM
+ *      the operations already extracted in step 2 — see the note on Step 5
+ *      below for why this must not re-extract. Scoped per-source by
+ *      `SourceEntry.exportMode` (BUG-APIGEN-034) via `opMatchesExportMode()`.
  *
  * @param opts - Orchestrator options.
  */
@@ -140,13 +201,17 @@ export declare function orchestrateGenerate(opts: OrchestratorOptions, plugin: O
  * @param opts          - Orchestrator options.
  * @param plugin        - The selected output plugin (`--type`).
  * @param buildFnTables - Async function that imports each source and returns
- *                        `(fns, createClient)` for that source.  Injected by
- *                        the command layer so the orchestrator stays testable
- *                        without live imports.
+ *                        `(fns, createClient)` for that source.  Receives the
+ *                        source's composed `ComposedSchemas` too, so the
+ *                        command layer can run schema-driven precondition
+ *                        guards (e.g. the `decimal.js` optional-peer-dep
+ *                        check) before importing the live module.  Injected
+ *                        by the command layer so the orchestrator stays
+ *                        testable without live imports.
  * @param signal        - Abort signal forwarded from the process SIGINT handler.
  * @param pluginOpts    - Plugin-level options.
  */
-export declare function orchestrateRun(opts: OrchestratorOptions, plugin: OutputPlugin, buildFnTables: (entry: SourceEntry) => Promise<{
+export declare function orchestrateRun(opts: OrchestratorOptions, plugin: OutputPlugin, buildFnTables: (entry: SourceEntry, schemas: ComposedSchemas) => Promise<{
     fns: Record<string, (...args: unknown[]) => unknown>;
     createClient: (envelope: Record<string, unknown>) => Promise<object>;
 }>, signal: AbortSignal, pluginOpts?: Record<string, unknown>): Promise<void>;

package/lib/plugin-registry.d.ts

@@ -0,0 +1,33 @@
+import { OutputPlugin } from '@adhd/apigen-core-client';
+
+/**
+ * Single source of truth for everything the CLI derives from the `--type`
+ * plugin registry: help text, `--list-types` output, and the "unknown
+ * --type"/"doesn't support run" errors. Every one of those was previously a
+ * hand-maintained string that drifted from the real `plugins` map passed
+ * into each command's `registerXCommand()` (FEAT-APIGEN-019) — this module
+ * is the only place that reads `Object.keys(plugins)` / `plugin.run` so
+ * they can never drift again.
+ */
+/** All registered `--type` ids, in registration order (includes aliases like `cli`/`cli-output`). */
+export declare function pluginTypeIds(plugins: Record<string, OutputPlugin>): string[];
+/** `--type` ids whose plugin implements `run()` — usable with `run` / `run-registry`. */
+export declare function runCapableTypeIds(plugins: Record<string, OutputPlugin>): string[];
+/** `--type` ids whose plugin has no `run()` — generate-only targets. */
+export declare function generateOnlyTypeIds(plugins: Record<string, OutputPlugin>): string[];
+/** Commander help text for `generate` / `generate-registry`'s `--type <plugin-id>` option. */
+export declare function describeTypeOption(plugins: Record<string, OutputPlugin>): string;
+/** Commander help text for `run` / `run-registry`'s `--type <plugin-id>` option (run-capable subset only). */
+export declare function describeRunTypeOption(plugins: Record<string, OutputPlugin>): string;
+/** The error thrown when `--type` isn't a registered plugin id at all. */
+export declare function unknownTypeError(type: string, plugins: Record<string, OutputPlugin>): Error;
+/**
+ * The error thrown when `--type` names a real, registered plugin that simply
+ * has no `run()` (e.g. `jsonschema`, `cli`) — distinct from {@link unknownTypeError}
+ * so a typo'd/unrecognized `--type` (e.g. `express` instead of `api-express`)
+ * doesn't get misreported as "exists but doesn't support run" (BACKLOG
+ * FEAT-APIGEN-019 live field confirmation).
+ */
+export declare function unsupportedRunError(type: string, plugins: Record<string, OutputPlugin>): Error;
+/** Human-readable multi-line listing for the `list-types` command. */
+export declare function formatTypesList(plugins: Record<string, OutputPlugin>): string;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@adhd/apigen-cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "bin": {
-    "apigen-cli": "./index.js"
+    "apigen": "./index.js"
   },
   "dependencies": {
     "commander": "^14.0.3",
@@ -15,13 +15,27 @@
     "pino": "10.3.1",
     "pino-pretty": "13.1.3",
     "pino-http": "11.0.0",
-    "@adhd/apigen-core": "^0.1.0",
-    "@adhd/apigen-runtime": "^0.1.0",
-    "@adhd/apigen-plugin-mcp": "^0.1.0",
-    "@adhd/apigen-plugin-jsonschema": "^0.1.0",
-    "@adhd/apigen-plugin-api-fastify": "^0.1.0",
-    "@adhd/apigen-plugin-api-express": "^0.1.0",
-    "@adhd/apigen-plugin-cli-output": "^0.1.0"
+    "@adhd/apigen-plugin-mcp": "^0.1.1",
+    "@adhd/apigen-plugin-jsonschema": "^0.1.1",
+    "@adhd/apigen-plugin-api-fastify": "^0.1.1",
+    "@adhd/apigen-plugin-api-express": "^0.1.1",
+    "@adhd/apigen-plugin-cli-output": "^0.1.1",
+    "@adhd/apigen-plugin-py-flask": "^0.1.1",
+    "@adhd/apigen-plugin-py-grpc": "^0.1.1",
+    "@adhd/apigen-plugin-health": "^0.1.2",
+    "@adhd/apigen-plugin-logger": "^0.1.2",
+    "@adhd/apigen-python-env": "^0.1.0",
+    "@adhd/apigen-base-logical": "^0.0.1",
+    "@adhd/apigen-engine-runtime": "^0.1.0",
+    "@adhd/apigen-core-client": "^0.1.0",
+    "@adhd/apigen-engine-naming": "^0.1.1",
+    "@adhd/apigen-plugin-openapi": "^0.1.2"
+  },
+  "peerDependencies": {},
+  "peerDependenciesMeta": {
+    "decimal.js": {
+      "optional": true
+    }
   },
   "main": "./index.js",
   "module": "./index.mjs",

package/default-tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true
-  }
-}

package/lib/pipeline.d.ts

@@ -1,22 +0,0 @@
-import { ComposedSchemas, ExportMode, Logger } from '@adhd/apigen-core';
-
-export interface PipelineOptions {
-    sourceFile: string;
-    exportMode?: ExportMode;
-    middlewares?: Array<{
-        id: string;
-        envelope?: Record<string, unknown>;
-    }>;
-    overrides?: Record<string, Record<string, boolean>>;
-    namespace?: string;
-    /** Explicit --tsconfig flag; when omitted, the nearest/builtin config is resolved from sourceFile. */
-    tsconfig?: string;
-    /** Optional shared logger; when present the pipeline logs schema extraction. */
-    logger?: Logger;
-}
-export interface PipelineResult {
-    schemas: ComposedSchemas;
-    createClient: (envelope: Record<string, unknown>) => Promise<object>;
-}
-/** Run the generate + compose pipeline for a single source file. */
-export declare function runPipeline(opts: PipelineOptions): Promise<PipelineResult>;