@aid-framework/cli 0.0.0 → 0.1.48

package/dist/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEtD;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY,EAAE,SAAiB;IAC1D,IAAI,SAAS,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IAClC,IAAI,UAAU,CAAC,SAAS,CAAC;QAAE,OAAO,OAAO,CAAC,SAAS,CAAC,CAAC;IACrD,OAAO,IAAI,CAAC,IAAI,EAAE,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAC7C,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,UAAU,CAAC,SAAiB;IAC1C,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACzC,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AACvD,CAAC"}

package/dist/pipeline.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The compile pipeline: read the spec, lower it to the IR, run every build-time gate,
+ * then ask the target to compile it.
+ *
+ * This is the sequence `packages/generators/py-fastapi/scripts/generate-example.mjs`
+ * already performs for the example app, and it is deliberately the *same* sequence
+ * rather than a parallel one: every step is a call into `@aid-framework/spec`, `@aid-framework/ir`,
+ * `@aid-framework/generator-sdk` or `@aid-framework/generator-py-fastapi`. The CLI introduces no gate, no
+ * hash, no drift rule and no manifest reader of its own -- a second implementation of a
+ * gate is a defect, because the two can disagree and only one of them will be right.
+ *
+ * Two behaviours worth stating because they are choices, not accidents:
+ *
+ * - Stages stop at the first error. Lowering a spec whose own schema did not validate
+ *   would report a cascade of consequences of the first mistake, which buries it.
+ *   Warnings produced before the stop are kept, because the design emits some
+ *   deliberately -- the eval-coverage gate warns rather than fails.
+ * - The target's compiler runs *before* its planner. `checkPlan` reports every problem
+ *   at once; `plan` throws. Asking first is what lets `aid gen` print the target's own
+ *   codes and paths instead of a stack trace with an exception dressed up as a
+ *   diagnostic.
+ */
+import { type AidManifest, type AidManifestProvenance, type Plan, type RegenerationSink } from '@aid-framework/generator-sdk';
+import type { IR } from '@aid-framework/ir';
+import type { CliContext } from './context.js';
+import type { CliDiagnostic } from './diagnostics.js';
+import type { Target } from './targets.js';
+/** A stage that judged the project and said no. */
+export interface Failed {
+    readonly ok: false;
+    readonly diagnostics: readonly CliDiagnostic[];
+}
+export interface ReadSpec {
+    readonly ok: true;
+    readonly text: string;
+}
+/** A spec that reduced to an IR the gates accepted. `diagnostics` holds its warnings. */
+export interface Lowered {
+    readonly ok: true;
+    readonly ir: IR;
+    readonly diagnostics: readonly CliDiagnostic[];
+}
+export type LowerOutcome = Lowered | Failed;
+/** A spec the target accepted, with the plan it produced. */
+export interface Compiled {
+    readonly ok: true;
+    readonly ir: IR;
+    readonly plan: Plan;
+    readonly diagnostics: readonly CliDiagnostic[];
+}
+export type CompileOutcome = Compiled | Failed;
+/** A manifest read back from the tree, or the diagnostics explaining why it was not. */
+export interface ReadManifest {
+    readonly ok: true;
+    readonly manifest: AidManifest | undefined;
+}
+export type ManifestOutcome = ReadManifest | Failed;
+export declare function readSpec(context: CliContext, specPath: string): ReadSpec | Failed;
+export declare function lowerSpec(text: string, file: string): LowerOutcome;
+export declare function compile(text: string, file: string, target: Target): CompileOutcome;
+/**
+ * The manifest the tree currently holds, read through the sink so that the path-escape
+ * guard and the "missing file is `undefined`" contract are the SDK's rather than this
+ * layer's. A manifest with an error in it is a failure, not a warning: generation
+ * cannot tell a hand edit from its own output without it.
+ */
+export declare function readManifest(sink: RegenerationSink, target: Target): ManifestOutcome;
+/**
+ * What the next manifest records about the run that wrote it, read off the target's own
+ * manifest so that the generator identity in the manifest and the generator that ran
+ * cannot disagree.
+ */
+export declare function provenanceFor(target: Target, ir: IR): AidManifestProvenance;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../src/pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,qBAAqB,EAC1B,KAAK,IAAI,EAET,KAAK,gBAAgB,EACtB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAI5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAG3C,mDAAmD;AACnD,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,WAAW,EAAE,SAAS,aAAa,EAAE,CAAC;CAChD;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,yFAAyF;AACzF,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC;IAChB,QAAQ,CAAC,WAAW,EAAE,SAAS,aAAa,EAAE,CAAC;CAChD;AAED,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,CAAC;AAE5C,6DAA6D;AAC7D,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC;IAChB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,SAAS,aAAa,EAAE,CAAC;CAChD;AAED,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE/C,wFAAwF;AACxF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,SAAS,CAAC;CAC5C;AAED,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,MAAM,CAAC;AAMpD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,CAgBjF;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAwBlE;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc,CASlF;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,CAYpF;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,GAAG,qBAAqB,CAM3E"}

package/dist/pipeline.js

@@ -0,0 +1,113 @@
+/**
+ * The compile pipeline: read the spec, lower it to the IR, run every build-time gate,
+ * then ask the target to compile it.
+ *
+ * This is the sequence `packages/generators/py-fastapi/scripts/generate-example.mjs`
+ * already performs for the example app, and it is deliberately the *same* sequence
+ * rather than a parallel one: every step is a call into `@aid-framework/spec`, `@aid-framework/ir`,
+ * `@aid-framework/generator-sdk` or `@aid-framework/generator-py-fastapi`. The CLI introduces no gate, no
+ * hash, no drift rule and no manifest reader of its own -- a second implementation of a
+ * gate is a defect, because the two can disagree and only one of them will be right.
+ *
+ * Two behaviours worth stating because they are choices, not accidents:
+ *
+ * - Stages stop at the first error. Lowering a spec whose own schema did not validate
+ *   would report a cascade of consequences of the first mistake, which buries it.
+ *   Warnings produced before the stop are kept, because the design emits some
+ *   deliberately -- the eval-coverage gate warns rather than fails.
+ * - The target's compiler runs *before* its planner. `checkPlan` reports every problem
+ *   at once; `plan` throws. Asking first is what lets `aid gen` print the target's own
+ *   codes and paths instead of a stack trace with an exception dressed up as a
+ *   diagnostic.
+ */
+import { readFileSync } from 'node:fs';
+import { parseAidManifestJson, } from '@aid-framework/generator-sdk';
+import { buildIR, runGates } from '@aid-framework/ir';
+import { checkSpecText, hasErrors, sortDiagnostics } from '@aid-framework/spec';
+import { CLI_DIAGNOSTIC_CODES, cliError } from './diagnostics.js';
+import { absolutePath } from './paths.js';
+import { targetCapabilities } from './targets.js';
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function readSpec(context, specPath) {
+    try {
+        return { ok: true, text: readFileSync(absolutePath(context.cwd, specPath), 'utf8') };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            diagnostics: [
+                cliError({
+                    code: CLI_DIAGNOSTIC_CODES.specUnreadable,
+                    message: `Cannot read the spec at "${specPath}": ${describeError(error)}`,
+                    path: [specPath],
+                    hint: 'Run `aid init` to scaffold a project, or pass the path to an existing spec.',
+                }),
+            ],
+        };
+    }
+}
+export function lowerSpec(text, file) {
+    const diagnostics = [];
+    const parsed = checkSpecText(text, { file });
+    diagnostics.push(...parsed.diagnostics);
+    if (!parsed.ok || parsed.value === undefined) {
+        return { ok: false, diagnostics: sortDiagnostics(diagnostics) };
+    }
+    const built = buildIR(parsed.value, { file });
+    diagnostics.push(...built.diagnostics);
+    if (hasErrors(built.diagnostics)) {
+        return { ok: false, diagnostics: sortDiagnostics(diagnostics) };
+    }
+    // The gates take the *generators'* capability declarations, not the IR package's
+    // placeholder: a gate run against a placeholder passes every spec and is not a gate.
+    const gates = runGates(built.ir, { targetCapabilities: targetCapabilities(), file });
+    diagnostics.push(...gates.diagnostics);
+    if (hasErrors(gates.diagnostics)) {
+        return { ok: false, diagnostics: sortDiagnostics(diagnostics) };
+    }
+    return { ok: true, ir: built.ir, diagnostics: sortDiagnostics(diagnostics) };
+}
+export function compile(text, file, target) {
+    const lowered = lowerSpec(text, file);
+    if (!lowered.ok)
+        return lowered;
+    const problems = target.check(lowered.ir);
+    const diagnostics = sortDiagnostics([...lowered.diagnostics, ...problems]);
+    if (hasErrors(problems))
+        return { ok: false, diagnostics };
+    return { ok: true, ir: lowered.ir, plan: target.plan(lowered.ir), diagnostics };
+}
+/**
+ * The manifest the tree currently holds, read through the sink so that the path-escape
+ * guard and the "missing file is `undefined`" contract are the SDK's rather than this
+ * layer's. A manifest with an error in it is a failure, not a warning: generation
+ * cannot tell a hand edit from its own output without it.
+ */
+export function readManifest(sink, target) {
+    const text = sink.read(target.manifestPath);
+    if (text === undefined)
+        return { ok: true, manifest: undefined };
+    const parsed = parseAidManifestJson(text, {
+        generatedDir: target.generatedDir,
+        businessDir: target.businessDir,
+    });
+    if (parsed.manifest === undefined || hasErrors(parsed.diagnostics)) {
+        return { ok: false, diagnostics: sortDiagnostics(parsed.diagnostics) };
+    }
+    return { ok: true, manifest: parsed.manifest };
+}
+/**
+ * What the next manifest records about the run that wrote it, read off the target's own
+ * manifest so that the generator identity in the manifest and the generator that ran
+ * cannot disagree.
+ */
+export function provenanceFor(target, ir) {
+    return {
+        generator: target.manifest.name,
+        generatorVersion: target.manifest.version,
+        irVersion: ir.irVersion,
+    };
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.js","sourceRoot":"","sources":["../src/pipeline.ts"],"names":[],"mappings":"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"}

package/dist/python.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The Python toolchain the commands that run generated code have to find.
+ *
+ * `aid eval` and `aid ingest` both shell out to a module the generator emitted, so both
+ * need the same two answers: which interpreter can actually import the runtime, and how
+ * to spawn it. Keeping the discovery here means there is one definition of "a usable
+ * interpreter" -- if the two commands each carried their own, an environment could work
+ * for one and not the other without anything explaining why.
+ *
+ * The contract is deliberately narrow: the caller names the module, and this file only
+ * decides which program runs it and from where. It knows nothing about evals or ingest.
+ */
+import type { CliContext, SpawnResult } from './context.js';
+/**
+ * Tried in order. The interpreter already active on this project comes first: it is the
+ * one the runtime was installed into. `uv` is last, and is kept because a uv-managed
+ * environment that has not been activated is a real setup where none of the others exist.
+ */
+export declare const INTERPRETERS: readonly ['python3', 'python', 'uv'];
+/** `uv run python` is a different argv shape from `python`, so it is not a rename. */
+export declare function interpreterCommand(interpreter: string): readonly string[];
+/**
+ * Spawn, or `undefined` when the program could not be executed at all. `spawnSync` reports
+ * a missing binary as `error` with a `null` status, and collapsing those two into one
+ * `undefined` is what lets discovery and the real run share a code path.
+ */
+export declare function invoke(context: CliContext, command: readonly string[], stdin?: string): SpawnResult | undefined;
+/** The first interpreter that can import the runtime, or `undefined` when none can. */
+export declare function discoverInterpreter(context: CliContext): string | undefined;
+//# sourceMappingURL=python.d.ts.map

package/dist/python.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python.d.ts","sourceRoot":"","sources":["../src/python.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE5D;;;;GAIG;AACH,eAAO,MAAM,YAAY,YAAI,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAU,CAAC;AAWjE,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAEzE;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CACpB,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,KAAK,CAAC,EAAE,MAAM,GACb,WAAW,GAAG,SAAS,CAUzB;AAED,uFAAuF;AACvF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAM3E"}

package/dist/python.js

@@ -0,0 +1,57 @@
+/**
+ * The Python toolchain the commands that run generated code have to find.
+ *
+ * `aid eval` and `aid ingest` both shell out to a module the generator emitted, so both
+ * need the same two answers: which interpreter can actually import the runtime, and how
+ * to spawn it. Keeping the discovery here means there is one definition of "a usable
+ * interpreter" -- if the two commands each carried their own, an environment could work
+ * for one and not the other without anything explaining why.
+ *
+ * The contract is deliberately narrow: the caller names the module, and this file only
+ * decides which program runs it and from where. It knows nothing about evals or ingest.
+ */
+/**
+ * Tried in order. The interpreter already active on this project comes first: it is the
+ * one the runtime was installed into. `uv` is last, and is kept because a uv-managed
+ * environment that has not been activated is a real setup where none of the others exist.
+ */
+export const INTERPRETERS = ['python3', 'python', 'uv'];
+/**
+ * Discovery asks whether a candidate can import the runtime, not merely whether it
+ * exists. A machine with a system `python` beside a project virtualenv has several
+ * interpreters, and picking the one that cannot `import aid_runtime` reports a missing
+ * dependency as a broken generated module. The probe is the import itself, so it cannot
+ * disagree with what the run will do a moment later.
+ */
+const RUNTIME_PROBE = 'import aid_runtime.evals';
+/** `uv run python` is a different argv shape from `python`, so it is not a rename. */
+export function interpreterCommand(interpreter) {
+    return interpreter === 'uv' ? ['uv', 'run', 'python'] : [interpreter];
+}
+/**
+ * Spawn, or `undefined` when the program could not be executed at all. `spawnSync` reports
+ * a missing binary as `error` with a `null` status, and collapsing those two into one
+ * `undefined` is what lets discovery and the real run share a code path.
+ */
+export function invoke(context, command, stdin) {
+    const [program, ...args] = command;
+    if (program === undefined)
+        return undefined;
+    const result = context.spawn(program, args, {
+        cwd: context.cwd,
+        stdio: 'pipe',
+        env: context.env,
+        ...(stdin === undefined ? {} : { stdin }),
+    });
+    return result.error === undefined ? result : undefined;
+}
+/** The first interpreter that can import the runtime, or `undefined` when none can. */
+export function discoverInterpreter(context) {
+    for (const interpreter of INTERPRETERS) {
+        const probe = invoke(context, [...interpreterCommand(interpreter), '-c', RUNTIME_PROBE]);
+        if (probe !== undefined && probe.status === 0)
+            return interpreter;
+    }
+    return undefined;
+}
+//# sourceMappingURL=python.js.map

package/dist/python.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"python.js","sourceRoot":"","sources":["../src/python.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAU,CAAC;AAEjE;;;;;;GAMG;AACH,MAAM,aAAa,GAAG,0BAA0B,CAAC;AAEjD,sFAAsF;AACtF,MAAM,UAAU,kBAAkB,CAAC,WAAmB;IACpD,OAAO,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;AACxE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,MAAM,CACpB,OAAmB,EACnB,OAA0B,EAC1B,KAAc;IAEd,MAAM,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,OAAO,CAAC;IACnC,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC5C,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE;QAC1C,GAAG,EAAE,OAAO,CAAC,GAAG;QAChB,KAAK,EAAE,MAAM;QACb,GAAG,EAAE,OAAO,CAAC,GAAG;QAChB,GAAG,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC;KAC1C,CAAC,CAAC;IACH,OAAO,MAAM,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AACzD,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,mBAAmB,CAAC,OAAmB;IACrD,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;QACvC,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,kBAAkB,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC;QACzF,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,WAAW,CAAC;IACpE,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/targets.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The target registry: the one place the CLI learns what a target *is*.
+ *
+ * A target is a generator plus the layout it declares. Nothing here restates that
+ * layout -- the spec path, the generated root, the business root, the manifest path and
+ * the eval module names all come from `@aid-framework/generator-sdk`'s `managedRoots` and
+ * `@aid-framework/generator-py-fastapi`'s path helpers, so a generator that moves a file moves
+ * every command with it, without the CLI being edited.
+ *
+ * The capability declarations are the SDK's `phase0TargetCapabilities`, not `@aid-framework/ir`'s
+ * placeholder of the same name. The placeholder exists so the gate could be written
+ * before a real generator existed; feeding it to the gate would make the capability gate
+ * pass vacuously for every spec, which is the one failure mode a gate must not have.
+ */
+import { type Generator, type GeneratorManifest, type Plan } from '@aid-framework/generator-sdk';
+import type { IR, TargetCapabilityDeclarations } from '@aid-framework/ir';
+import type { CliDiagnostic } from './diagnostics.js';
+/**
+ * How `aid eval` and `aid ingest` run a target's generated entry points.
+ *
+ * Both commands used to assume CPython: they discover an interpreter and run `-m`. A
+ * target whose emitted modules are not Python has no such entry point, and the honest
+ * answer is a diagnostic, not a Python traceback about a missing module.
+ */
+export type TargetRunner = 'python' | 'node';
+export interface Target {
+    /** The target id, as a spec's `project.targets` spells it. */
+    readonly name: string;
+    /** The spec this target's project is expected to keep, repo-relative. */
+    readonly specPath: string;
+    readonly generatedDir: string;
+    readonly businessDir: string;
+    readonly manifestPath: string;
+    /** The generated evals package, repo-relative. */
+    readonly evalsDir: string;
+    readonly manifest: GeneratorManifest;
+    readonly generator: Generator;
+    /** Which toolchain `aid eval` and `aid ingest` would need to run this target. */
+    readonly runner: TargetRunner;
+    /** Everything that stops this target compiling the IR, as diagnostics. */
+    check(ir: IR): readonly CliDiagnostic[];
+    plan(ir: IR): Plan;
+    /** The dotted module path of the generated eval module for `evalId`. */
+    evalModule(evalId: string): string;
+    /** The repo-relative file the generated eval module for `evalId` lives in. */
+    evalModuleFile(evalId: string): string;
+    /** The dotted module path of the generated ingest module for `retrieverId`. */
+    retrievalIngestModule(retrieverId: string): string;
+    /** The repo-relative file the generated ingest module for `retrieverId` lives in. */
+    retrievalIngestModuleFile(retrieverId: string): string;
+}
+/**
+ * The registry. Order matters only for the default: the first entry is what `aid gen`,
+ * `aid validate` and `aid init` use when the caller names no target, and that has been
+ * `py-fastapi` since Phase 0.
+ */
+export declare const TARGETS: readonly Target[];
+export declare const DEFAULT_TARGET: string;
+/** Where `aid validate` and `aid gen` look when the caller names no spec. */
+export declare const DEFAULT_SPEC_PATH: string;
+export declare function targetNames(): string[];
+/** The named target, the default when `name` is absent, or `undefined` when unknown. */
+export declare function resolveTarget(name: string | undefined): Target | undefined;
+/**
+ * The capability declarations the build-time gates are run against.
+ *
+ * Derived from this registry rather than from the SDK's own `phase0Generators`, because
+ * the registry is the list of generators this binary can actually run: a spec targeting
+ * `ts-vercel` must be judged against `ts-vercel`'s declaration, and the SDK cannot name
+ * a generator that depends on the SDK.
+ */
+export declare function targetCapabilities(): TargetCapabilityDeclarations;
+/** Diagnostics for a target id the registry does not know. */
+export declare function unknownTargetDiagnostic(name: string): CliDiagnostic;
+//# sourceMappingURL=targets.d.ts.map

package/dist/targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../src/targets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAUH,OAAO,EACL,KAAK,SAAS,EACd,KAAK,iBAAiB,EAEtB,KAAK,IAAI,EAEV,MAAM,8BAA8B,CAAC;AAStC,OAAO,KAAK,EAAE,EAAE,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AAG1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAiBtD;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE7C,MAAM,WAAW,MAAM;IACrB,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,iFAAiF;IACjF,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,0EAA0E;IAC1E,KAAK,CAAC,EAAE,EAAE,EAAE,GAAG,SAAS,aAAa,EAAE,CAAC;IACxC,IAAI,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC;IACnB,wEAAwE;IACxE,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACnC,8EAA8E;IAC9E,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACvC,+EAA+E;IAC/E,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IACnD,qFAAqF;IACrF,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;CACxD;AA2ED;;;;GAIG;AACH,eAAO,MAAM,OAAO,EAAE,SAAS,MAAM,EAuBpC,CAAC;AAOF,eAAO,MAAM,cAAc,QAAe,CAAC;AAE3C,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,QAAmB,CAAC;AAElD,wBAAgB,WAAW,IAAI,MAAM,EAAE,CAEtC;AAED,wFAAwF;AACxF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAG1E;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,IAAI,4BAA4B,CAEjE;AAED,8DAA8D;AAC9D,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAOnE"}

package/dist/targets.js

@@ -0,0 +1,136 @@
+/**
+ * The target registry: the one place the CLI learns what a target *is*.
+ *
+ * A target is a generator plus the layout it declares. Nothing here restates that
+ * layout -- the spec path, the generated root, the business root, the manifest path and
+ * the eval module names all come from `@aid-framework/generator-sdk`'s `managedRoots` and
+ * `@aid-framework/generator-py-fastapi`'s path helpers, so a generator that moves a file moves
+ * every command with it, without the CLI being edited.
+ *
+ * The capability declarations are the SDK's `phase0TargetCapabilities`, not `@aid-framework/ir`'s
+ * placeholder of the same name. The placeholder exists so the gate could be written
+ * before a real generator existed; feeding it to the gate would make the capability gate
+ * pass vacuously for every spec, which is the one failure mode a gate must not have.
+ */
+import { checkPlan as checkPyFastApi, EVALS_INIT_PATH, PY_FASTAPI_MANIFEST, evalModulePath as pyFastApiEvalModulePath, pyFastApiGenerator, retrievalIngestModulePath as pyFastApiIngestModulePath, } from '@aid-framework/generator-py-fastapi';
+import { managedRoots, targetCapabilityDeclarations, } from '@aid-framework/generator-sdk';
+import { checkPlan as checkTsVercel, TS_VERCEL_MANIFEST, evalModulePath as tsVercelEvalModulePath, tsVercelGenerator, retrievalIngestModulePath as tsVercelIngestModulePath, paths as tsVercelPaths, } from '@aid-framework/generator-ts-vercel';
+import { errorDiagnostic } from '@aid-framework/spec';
+import { CLI_DIAGNOSTIC_CODES } from './diagnostics.js';
+import { parentPath } from './paths.js';
+function dotted(path, extension) {
+    return path
+        .replace(new RegExp(`${extension.replace('.', '\\.')}$`), '')
+        .split('/')
+        .join('.');
+}
+function targetFor(module) {
+    const { manifest } = module;
+    const roots = managedRoots(manifest);
+    return {
+        name: manifest.target,
+        specPath: `${manifest.output.root}/app.spec.yaml`,
+        generatedDir: roots.generatedDir,
+        businessDir: roots.businessDir,
+        manifestPath: roots.manifestFilename,
+        evalsDir: parentPath(module.evalsIndexPath),
+        manifest,
+        generator: module.generator,
+        runner: module.runner,
+        // `checkPlan` is the target's own compiler, and it throws the same problems
+        // `plan` does. Reporting them through it means the CLI prints the target's codes
+        // and paths verbatim: no catching, no renaming, no second opinion about what is
+        // wrong with a spec.
+        check(ir) {
+            return module.checkPlan(ir).map((problem) => errorDiagnostic({
+                code: problem.code,
+                message: problem.message,
+                path: [problem.path],
+            }));
+        },
+        plan(ir) {
+            return module.generator.plan(ir, {
+                generatorVersion: manifest.version,
+                root: manifest.output.root,
+            });
+        },
+        evalModuleFile(evalId) {
+            return module.evalModulePath(evalId);
+        },
+        evalModule(evalId) {
+            return dotted(module.evalModulePath(evalId), module.extension);
+        },
+        retrievalIngestModuleFile(retrieverId) {
+            return module.retrievalIngestModulePath(retrieverId);
+        },
+        retrievalIngestModule(retrieverId) {
+            return dotted(module.retrievalIngestModulePath(retrieverId), module.extension);
+        },
+    };
+}
+/**
+ * The registry. Order matters only for the default: the first entry is what `aid gen`,
+ * `aid validate` and `aid init` use when the caller names no target, and that has been
+ * `py-fastapi` since Phase 0.
+ */
+export const TARGETS = [
+    targetFor({
+        manifest: PY_FASTAPI_MANIFEST,
+        generator: pyFastApiGenerator,
+        runner: 'python',
+        extension: '.py',
+        evalsIndexPath: EVALS_INIT_PATH,
+        evalModulePath: pyFastApiEvalModulePath,
+        retrievalIngestModulePath: pyFastApiIngestModulePath,
+        checkPlan: checkPyFastApi,
+    }),
+    targetFor({
+        manifest: TS_VERCEL_MANIFEST,
+        generator: tsVercelGenerator,
+        runner: 'node',
+        // The generated modules are `.ts` on disk and `.js` once compiled; the dotted name
+        // is the same either way, and the path helpers hand back the file that exists.
+        extension: '.ts',
+        evalsIndexPath: tsVercelPaths.evalsIndex,
+        evalModulePath: tsVercelEvalModulePath,
+        retrievalIngestModulePath: tsVercelIngestModulePath,
+        checkPlan: checkTsVercel,
+    }),
+];
+const [primary] = TARGETS;
+if (primary === undefined) {
+    throw new Error('No Phase 0 target is registered.');
+}
+export const DEFAULT_TARGET = primary.name;
+/** Where `aid validate` and `aid gen` look when the caller names no spec. */
+export const DEFAULT_SPEC_PATH = primary.specPath;
+export function targetNames() {
+    return TARGETS.map((target) => target.name);
+}
+/** The named target, the default when `name` is absent, or `undefined` when unknown. */
+export function resolveTarget(name) {
+    if (name === undefined)
+        return primary;
+    return TARGETS.find((target) => target.name === name);
+}
+/**
+ * The capability declarations the build-time gates are run against.
+ *
+ * Derived from this registry rather than from the SDK's own `phase0Generators`, because
+ * the registry is the list of generators this binary can actually run: a spec targeting
+ * `ts-vercel` must be judged against `ts-vercel`'s declaration, and the SDK cannot name
+ * a generator that depends on the SDK.
+ */
+export function targetCapabilities() {
+    return targetCapabilityDeclarations(TARGETS.map((target) => target.manifest));
+}
+/** Diagnostics for a target id the registry does not know. */
+export function unknownTargetDiagnostic(name) {
+    return errorDiagnostic({
+        code: CLI_DIAGNOSTIC_CODES.unknownTarget,
+        message: `Unknown target \`${name}\`.`,
+        path: [],
+        hint: `Known targets: ${targetNames().join(', ')}.`,
+    });
+}
+//# sourceMappingURL=targets.js.map

package/dist/targets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"targets.js","sourceRoot":"","sources":["../src/targets.ts"],"names":[],"mappings":"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"}

package/dist/usage.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Usage text, rendered from the same flag specs the parser enforces.
+ *
+ * Help that is written by hand drifts from the parser the first time a flag is added, and
+ * a help text listing a flag that does not exist is worse than no help. So one command
+ * table is the single source: `main.ts` registers each command with its flags, the parser
+ * validates against those flags, and these functions render them.
+ */
+import type { FlagSpec } from './args.js';
+export interface CommandSpec {
+    readonly name: string;
+    /** One line, shown in the global listing. */
+    readonly summary: string;
+    /** The invocation shape, as the user would type it. */
+    readonly usage: string;
+    readonly flags: readonly FlagSpec[];
+}
+export declare function commandUsage(command: CommandSpec): string;
+export declare function globalUsage(commands: readonly CommandSpec[]): string;
+//# sourceMappingURL=usage.d.ts.map

package/dist/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../src/usage.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1C,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CACrC;AAaD,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAYzD;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CAiBpE"}

package/dist/usage.js

@@ -0,0 +1,49 @@
+/**
+ * Usage text, rendered from the same flag specs the parser enforces.
+ *
+ * Help that is written by hand drifts from the parser the first time a flag is added, and
+ * a help text listing a flag that does not exist is worse than no help. So one command
+ * table is the single source: `main.ts` registers each command with its flags, the parser
+ * validates against those flags, and these functions render them.
+ */
+/** The parser treats `help` specially; the help text still has to mention it. */
+const HELP = {
+    name: 'help',
+    kind: 'boolean',
+    summary: "print this command's usage",
+};
+function flagLabel(flag) {
+    return flag.kind === 'value' ? `--${flag.name} <${flag.value ?? 'value'}>` : `--${flag.name}`;
+}
+export function commandUsage(command) {
+    const flags = [...command.flags, HELP];
+    const width = Math.max(...flags.map((flag) => flagLabel(flag).length));
+    return [
+        `Usage: aid ${command.usage}`,
+        '',
+        command.summary,
+        '',
+        'Options:',
+        ...flags.map((flag) => `  ${flagLabel(flag).padEnd(width)}  ${flag.summary}`),
+        '',
+    ].join('\n');
+}
+export function globalUsage(commands) {
+    const width = Math.max(...commands.map((command) => command.name.length));
+    return [
+        'aid - the AID Framework CLI.',
+        '',
+        'Usage: aid <command> [arguments] [options]',
+        '',
+        'Commands:',
+        ...commands.map((command) => `  ${command.name.padEnd(width)}  ${command.summary}`),
+        '',
+        'Every command answers `--json` with one JSON document on stdout and `-h` with its',
+        'usage. Exit codes: 0 the project is as asked, 1 the spec, a gate, the target or the',
+        'working tree said no, 2 the invocation was wrong or the CLI failed internally.',
+        '',
+        "Run `aid <command> --help` for a command's options.",
+        '',
+    ].join('\n');
+}
+//# sourceMappingURL=usage.js.map

package/dist/usage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.js","sourceRoot":"","sources":["../src/usage.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH,iFAAiF;AACjF,MAAM,IAAI,GAAa;IACrB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,SAAS;IACf,OAAO,EAAE,4BAA4B;CACtC,CAAC;AAEF,SAAS,SAAS,CAAC,IAAc;IAC/B,OAAO,IAAI,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,KAAK,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;AAChG,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,OAAoB;IAC/C,MAAM,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACvC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IACvE,OAAO;QACL,cAAc,OAAO,CAAC,KAAK,EAAE;QAC7B,EAAE;QACF,OAAO,CAAC,OAAO;QACf,EAAE;QACF,UAAU;QACV,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,SAAS,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,OAAO,EAAE,CAAC;QAC7E,EAAE;KACH,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,QAAgC;IAC1D,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1E,OAAO;QACL,8BAA8B;QAC9B,EAAE;QACF,4CAA4C;QAC5C,EAAE;QACF,WAAW;QACX,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC;QACnF,EAAE;QACF,mFAAmF;QACnF,qFAAqF;QACrF,gFAAgF;QAChF,EAAE;QACF,qDAAqD;QACrD,EAAE;KACH,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}