@ogygie/generate 0.0.0-stage → 0.19.0

package/dist/cli/check-command.d.ts

@@ -0,0 +1,3 @@
+import { type GenerateProject } from "./project.js";
+import type { CommandOutput } from "./output.js";
+export declare function runCheckCommand(project: GenerateProject, featureId: string | undefined, out: CommandOutput): Promise<number>;

package/dist/cli/fill-command.d.ts

@@ -0,0 +1,39 @@
+import { type HoleLibraryEntry } from "../hole-shape.js";
+import { type FillOptions } from "../fill/fill.js";
+import { type FillModels } from "../fill/model-draw.js";
+import type { CommandOutput } from "./output.js";
+import { type GenerateProject } from "./project.js";
+export interface FillCommandFlags {
+    options: FillOptions;
+    models: FillModels;
+}
+/** `--candidates <n> --rounds <n> --draw <model> --escalate <model> --library-only`. */
+export declare function parseFillFlags(argv: readonly string[]): FillCommandFlags;
+/** The variables a subprocess that runs a candidate body may see: the path to its tools, its home, nothing that is a secret. */
+export declare function scrubbedEnvironment(env: Readonly<Record<string, string | undefined>>): Record<string, string>;
+export interface HoleTestRunner {
+    (input: {
+        projectRoot: string;
+        testPath: string;
+        holeId: string;
+    }): {
+        green: boolean;
+        lines: string[];
+    };
+}
+/** The real runner: the product's Vitest on the hole's own describe, in a process that holds no secret. */
+export declare const vitestHoleRunner: HoleTestRunner;
+export interface FillCommandDeps {
+    runner?: HoleTestRunner;
+    /** The model key — absent, the command fills from the library alone and says so. */
+    modelApiKey?: string | undefined;
+    fetchImpl?: typeof fetch;
+    libraryDir?: string;
+    /** `$GITHUB_STEP_SUMMARY` when CI offers one: the usage table lands there (B8). */
+    summaryPath?: string | undefined;
+    repo?: string;
+    today?: () => string;
+}
+/** An entry recorded in the library: a new file, or the provenance of an existing one extended. */
+export declare function recordLibraryEntry(libraryDir: string, entry: HoleLibraryEntry): "created" | "extended" | "unchanged";
+export declare function runFillCommand(project: GenerateProject, featureId: string | undefined, argv: readonly string[], out: CommandOutput, deps?: FillCommandDeps): Promise<number>;

package/dist/cli/generate-command.d.ts

@@ -0,0 +1,8 @@
+import type { CommandOutput } from "./output.js";
+import { type GenerateProject } from "./project.js";
+/**
+ * `generate --all`: every generated spec of the map, one after the other; the project is reloaded between two features
+ * because each one may rewrite the map. Code 1 when any of them refused, after the others ran.
+ */
+export declare function runGenerateAllCommand(project: GenerateProject, out: CommandOutput): Promise<number>;
+export declare function runGenerateFeatureCommand(project: GenerateProject, featureId: string | undefined, out: CommandOutput): Promise<number>;

package/dist/cli/generate-screen-command.d.ts

@@ -0,0 +1,6 @@
+import { type ConsumedFeatureInput } from "../emit/screen-plan.js";
+import type { CommandOutput } from "./output.js";
+import { type GenerateProject, type LoadedConsumedFeature } from "./project.js";
+/** The consumed features a plan can be built on: every one with its schemas — with or without a block (D41 precision) — `check` refused the rest. */
+export declare function consumedInputsOf(loaded: ReadonlyMap<string, LoadedConsumedFeature>): ConsumedFeatureInput[];
+export declare function runGenerateScreenCommand(project: GenerateProject, featureId: string, out: CommandOutput): Promise<number>;

package/dist/cli/output.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @intent Where a command of the generator writes: two sinks the caller
+ * provides — the CLI relay gives the console, a test gives arrays — so the
+ * commands never touch `process` themselves and return their exit code.
+ */
+export interface CommandOutput {
+    log: (line: string) => void;
+    error: (line: string) => void;
+}

package/dist/cli/preview-command.d.ts

@@ -0,0 +1,19 @@
+import type { CommandOutput } from "./output.js";
+import { type GenerateProject } from "./project.js";
+export declare const PREVIEWS_ROOT = "previews";
+/** Where a screen's pages go: its folder, then the composition's when the spec declares one (D53). */
+export declare function previewsDirOf(featureId: string, composition: string | null): string;
+export interface PreviewRunner {
+    /** Runs the emitted previews test with the output directory in its environment; returns the runner's exit code and its lines. */
+    (input: {
+        projectRoot: string;
+        testPath: string;
+        outDir: string;
+    }): {
+        code: number;
+        lines: string[];
+    };
+}
+/** The real runner: the product's Vitest, from the project root, as `pnpm test -- <path>` would. */
+export declare const vitestPreviewRunner: PreviewRunner;
+export declare function runPreviewCommand(project: GenerateProject, featureId: string | undefined, out: CommandOutput, runner?: PreviewRunner): Promise<number>;

package/dist/cli/project.d.ts

@@ -0,0 +1,97 @@
+import { OgygieManifestSchema } from "@ogygie/core/manifest";
+import { type OgygieError } from "@ogygie/core/errors";
+import { type FrontTarget, type ManifestGeneration } from "../manifest-generation.schema.js";
+import type { ConsumedRoute } from "../emit/screen-plan.js";
+import type { GenerationBlock } from "../generation-block.schema.js";
+import type { ScreenBlock } from "../screen-block.schema.js";
+import type { SpecOwnerFolder } from "../verify-generation.js";
+import { type SchemaModels } from "../zod-introspection.js";
+export declare const MANIFEST_FILE = "ogygie.manifest.json";
+export declare const GENERATE_PROJECT_INVALID = "OGYGIE_GENERATE_PROJECT_INVALID";
+type Manifest = ReturnType<typeof OgygieManifestSchema.parse>;
+type Feature = Manifest["features"][number];
+export interface GenerateProject {
+    root: string;
+    /** The manifest as parsed, every key kept — what `generate` writes back. */
+    rawManifest: unknown;
+    manifest: Manifest;
+    /** The `generation` block, null when the product declares none. */
+    generation: ManifestGeneration | null;
+    apiApp: Manifest["apps"][number] | undefined;
+    /** Folder of the specs, as the manifest declares it. */
+    specsFolder: string;
+    /** Where generated files may live: every app and package the map declares, once each. */
+    scanDirs: string[];
+    /** Spec → owning feature folder and the generated fields of its entry. */
+    owners: SpecOwnerFolder[];
+}
+export type ProjectOutcome = {
+    ok: true;
+    project: GenerateProject;
+} | {
+    ok: false;
+    problems: OgygieError[];
+};
+/** Reads the project once; a manifest the core refuses, or a generation block the package refuses, is a refusal here too. */
+export declare function loadGenerateProject(root: string): ProjectOutcome;
+/** A feature the generator can work on: on the map, with a spec, under the api app, with a tenant column to scope its table. */
+export interface FeatureTarget {
+    feature: Feature;
+    featureId: string;
+    /** Repo-relative folder of the feature. */
+    folder: string;
+    specPath: string;
+    appPath: string;
+    tenantColumn: string | undefined;
+    generation: ManifestGeneration;
+}
+export declare function featureTargetOf(project: GenerateProject, featureId: string): {
+    ok: true;
+    target: FeatureTarget;
+} | {
+    ok: false;
+    problem: OgygieError;
+};
+/**
+ * Imports a module of the PRODUCT — TypeScript on disk (D19, D55): the native
+ * import when the host runs the TypeScript (tsx, vitest, a node that strips
+ * types and finds the files), else `tsImport` of tsx's API, which the package
+ * carries so `node dist/cli.js` never depends on the host's loader. The
+ * `.js` specifiers of a product's TypeScript are what plain node trips on.
+ */
+export declare function importProductModule(url: string): Promise<Record<string, unknown>>;
+/** Imports a schemas module as the app would and models its *Schema exports; null when absent. */
+export declare function schemaModelsLoader(root: string): (modulePath: string) => Promise<SchemaModels | null>;
+/** Stable output for a problem — one JSON document per line block, the shape every Ogygie gate prints. */
+export declare function formatProblem(problem: OgygieError): string;
+/** D40, D41: a SCREEN the generator can work on — a feature carried by a front app, with a spec, under a front target. */
+export interface ScreenTarget {
+    feature: Feature;
+    featureId: string;
+    /** Repo-relative folder of the screen feature. */
+    folder: string;
+    specPath: string;
+    /** Path of the front app carrying the feature, relative to the repo root. */
+    appPath: string;
+    front: FrontTarget;
+    generation: ManifestGeneration;
+}
+/** Which kind of target a feature of the map is: a feature under the api app, or a screen under a front app. */
+export declare function targetKindOf(project: GenerateProject, featureId: string): "feature" | "screen" | null;
+export declare function screenTargetOf(project: GenerateProject, featureId: string): {
+    ok: true;
+    target: ScreenTarget;
+} | {
+    ok: false;
+    problem: OgygieError;
+};
+/** A consumed feature as a screen needs it: its block (null when its spec has none), its schemas (null when absent), its routes on the map. */
+export interface LoadedConsumedFeature {
+    featureId: string;
+    block: GenerationBlock | null;
+    schemas: SchemaModels | null;
+    routes: ConsumedRoute[];
+}
+/** Resolves every feature a screen block consumes: spec read and checked, schemas introspected, routes read from the map. A feature the map does not know is absent from the result — the checks name it. */
+export declare function loadConsumedFeatures(project: GenerateProject, block: ScreenBlock): Promise<Map<string, LoadedConsumedFeature>>;
+export {};

package/dist/cli/run.d.ts

@@ -0,0 +1,13 @@
+export declare const GENERATE_COMMANDS: readonly ["check", "generate", "verify", "preview", "fill", "schemas"];
+export type GenerateCommandName = (typeof GENERATE_COMMANDS)[number];
+export declare const GENERATE_USAGE = "OGYGIE_GENERATE_USAGE";
+export interface RunGenerateCommandInput {
+    /** Root of the project — where ogygie.manifest.json lives. */
+    projectRoot: string;
+    /** Everything after `ogygie generate`: the subcommand, then its arguments. */
+    argv: readonly string[];
+    log: (line: string) => void;
+    error: (line: string) => void;
+}
+/** Runs one command of the generator and returns its exit code — 0 when the judgment is clean. */
+export declare function runGenerateCommand(input: RunGenerateCommandInput): Promise<number>;