argsbarg 6.0.1 → 6.1.0

package/examples/full-example/src/commands/status/types.ts

@@ -1 +1,19 @@
-export type { StatusJsonOutput } from "./schema-types.ts";
+/** JSON stdout for `full-example status --json`. */
+export interface StatusJsonOutput {
+  /** Resolved AWS region. */
+  defaultRegion?: string;
+  /** Resolved retry count. */
+  maxRetries?: number;
+  /** Whether apiToken is set (value never included). */
+  apiTokenSet: boolean;
+  /** App version from program root. */
+  version: string;
+}
+
+/** Returns status JSON (identity helper for schema generation). */
+export function buildStatusJson(output: StatusJsonOutput): StatusJsonOutput {
+  return output;
+}
+
+/** Schemagen root for leaf outputSchema. */
+export type outputType = StatusJsonOutput;

package/examples/full-example/src/config/__generated__/index.ts

@@ -0,0 +1,5 @@
+// Auto-generated by argsbarg schemagen — do not edit by hand.
+
+import configSchemaJson from "./configSchema.json";
+
+export const configSchema = configSchemaJson as Record<string, unknown>;

package/examples/full-example/src/program.ts

@@ -4,12 +4,12 @@ Kitchen-sink CliProgram — every argsbarg builtin enabled; command registration
 
 import type { CliAppConfig, CliAppConfigEntry, CliProgram } from "argsbarg";
 import readmeText from "../README.md" with { type: "text" };
-import { APP_CONFIG_JSON_SCHEMA } from "../schemas/configSchemas.ts";
 import { createIdentity } from "../scripts/create-identity.ts";
 import { echoCommand } from "./commands/echo/command.ts";
 import { statusCommand } from "./commands/status/command.ts";
+import { configSchema } from "./config/__generated__/index.ts";
 
-const configSchema = {
+const configEntries = {
   apiToken: {
     description: "Create at https://example.com/settings/tokens",
     env: `${createIdentity.envPrefix}_API_TOKEN`,
@@ -34,8 +34,8 @@ export const program = {
   version: "1.0.0",
   description: createIdentity.desc,
   appConfig: {
-    jsonSchema: APP_CONFIG_JSON_SCHEMA,
-    entries: configSchema,
+    jsonSchema: configSchema,
+    entries: configEntries,
   } satisfies CliAppConfig,
   docs: {
     enabled: true,

package/index.d.ts

@@ -45,7 +45,7 @@ declare class AppConfigSnapshot {
 }
 export type AnyAppConfigSnapshot = AppConfigSnapshot | EmptyAppConfigSnapshot;
 /** Coerced leaf inputs keyed by option and positional names. */
-export type CliLeafInputs = Record<string, boolean | number | string | string[] | undefined>;
+export type CliLeafInputs = Record<string, boolean | number | string | string[] | unknown | undefined>;
 /**
  * Values passed to a leaf command handler after parsing: app name, routed path, args, and merged options.
  */
@@ -92,6 +92,11 @@ export declare class CliContext {
 	positional(name: string): string | string[] | undefined;
 	/** Reads coerced option and positional values for the current leaf from schema metadata. */
 	readLeafInputs(): CliLeafInputs;
+	/**
+	 * Reads coerced leaf inputs, resolving Json options from flags, piped stdin (when `pipable`),
+	 * or MCP/API toolArgs, and validates against `leaf.inputSchema` when set.
+	 */
+	readLeafInputsAsync(): Promise<CliLeafInputs>;
 	private _readOptionValue;
 	private _leafNode;
 	private _posMap;
@@ -102,7 +107,7 @@ export declare class CliContext {
  */
 export type CliInvocation = "cli" | "mcp" | "api";
 /**
- * Option kinds: presence (boolean flag), string (free-form text), number (strict double), or enum (fixed choices).
+ * Option kinds: presence (boolean flag), string (free-form text), number (strict double), enum (fixed choices), or json (parsed JSON object/array).
  */
 export declare enum CliOptionKind {
 	/** Boolean flag: no value token (may be implicit `"1"` when set). */
@@ -112,7 +117,9 @@ export declare enum CliOptionKind {
 	/** Strict floating-point value (parsed at validation time). */
 	Number = "number",
 	/** Fixed set of allowed string values. Requires non-empty `choices` on the option. */
-	Enum = "enum"
+	Enum = "enum",
+	/** JSON object or array (parsed from `--name '<json>'`, piped stdin when `pipable`, or MCP/API tool body). */
+	Json = "json"
 }
 /**
  * Named validation/coercion for string options (`format` on `CliOption`).
@@ -176,6 +183,11 @@ export interface CliOption {
 	default?: string;
 	/** Regex pattern for string options. Mutually exclusive with `format`. */
 	pattern?: string;
+	/**
+	 * When `true` on a `Json` option, CLI may omit `--name` and supply JSON via stdin instead.
+	 * If `--name` is set, the flag value wins and stdin is not read.
+	 */
+	pipable?: boolean;
 }
 /**
  * An ordered positional argument slot, listed on leaf `positionals`.
@@ -631,6 +643,15 @@ dryRun?: boolean,
 interactive?: boolean): void;
 /** Prefixes a success message when running in dry-run mode. */
 export declare function formatDryRunMessage(message: string, dryRun: boolean): string;
+/** Thrown when {@link CliContext.readLeafInputsAsync} cannot resolve or validate inputs. */
+export declare class LeafInputError extends Error {
+	constructor(message: string);
+}
+/**
+ * Reads coerced leaf inputs, resolving Json options from flags, piped stdin, or toolArgs,
+ * and validates against `leaf.inputSchema` when set.
+ */
+export declare function readLeafInputsAsync(ctx: CliContext): Promise<CliLeafInputs>;
 /** Resolved paths for `mcp bundle`. */
 export interface McpBundlePaths {
 	binaryPath: string;

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "argsbarg",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "main": "./src/index.ts",
   "module": "./src/index.ts",
+  "dependencies": {
+    "ts-json-schema-generator": "^2.3.0"
+  },
   "devDependencies": {
     "@biomejs/biome": "^2.5.0",
     "@types/bun": "^1.3.12",
@@ -13,6 +16,10 @@
     ".": {
       "types": "./index.d.ts",
       "default": "./src/index.ts"
+    },
+    "./schemagen": {
+      "types": "./src/cli-tool/schemagen/index.ts",
+      "default": "./src/cli-tool/schemagen/index.ts"
     }
   },
   "bin": {

package/src/cli-tool/full-example-capabilities.test.ts

@@ -63,7 +63,8 @@ describe("full-example template", () => {
 
   test("status command defines outputSchema", () => {
     const statusSource = readFileSync(join(exampleRoot, "src/commands/status/command.ts"), "utf8");
-    expect(statusSource).toContain("outputSchema:");
+    expect(statusSource).toMatch(/outputSchema[,:]/);
+    expect(statusSource).toContain('from "./__generated__/index.ts"');
   });
 
   test("resolveCapabilities matches full sink shape", () => {

package/src/cli-tool/post-create.ts

@@ -41,10 +41,10 @@ export async function runPostCreate(targetDir: string, dryRun: boolean): Promise
       },
     },
     {
-      label: "bun scripts/schemagen.ts",
+      label: "argsbarg schemagen",
       run: () => {
         if (dryRun) return;
-        const proc = Bun.spawnSync(["bun", "scripts/schemagen.ts"], {
+        const proc = Bun.spawnSync(["argsbarg", "schemagen"], {
           cwd: abs,
           stdout: "inherit",
           stderr: "inherit",
@@ -103,7 +103,7 @@ export async function runPostCreate(targetDir: string, dryRun: boolean): Promise
 export function printPostCreatePlan(): void {
   process.stderr.write("Post-create steps:\n");
   process.stderr.write("  1. bun install\n");
-  process.stderr.write("  2. bun scripts/schemagen.ts\n");
+  process.stderr.write("  2. just schemagen\n");
   process.stderr.write("  3. bun test\n");
   process.stderr.write("  4. git init + Initial commit (skipped inside existing git work tree)\n");
 }

package/src/cli-tool/program.ts

@@ -5,6 +5,7 @@ Argsbarg developer tools — bootstrap consumer CLIs via `create`.
 import pkg from "../../package.json" with { type: "json" };
 import { CliOptionKind, type CliProgram } from "../index.ts";
 import { runCreate } from "./run-create.ts";
+import { runSchemagenCli } from "./run-schemagen.ts";
 
 export const program = {
   key: "argsbarg",
@@ -92,5 +93,40 @@ export const program = {
         process.exit(code);
       },
     },
+    {
+      key: "schemagen",
+      description:
+        "Generate JSON Schema artifacts from src/**/types.ts role exports into colocated __generated__/ directories.",
+      options: [
+        {
+          name: "root",
+          description: "Project root (default: current working directory).",
+          kind: CliOptionKind.String,
+        },
+        {
+          name: "src-dir",
+          description: "Source directory relative to --root (default: src).",
+          kind: CliOptionKind.String,
+        },
+        {
+          name: "tsconfig",
+          description: "Path to tsconfig relative to --root (default: tsconfig.json).",
+          kind: CliOptionKind.String,
+        },
+      ],
+      handler: (ctx) => {
+        try {
+          runSchemagenCli({
+            root: ctx.stringOpt("root"),
+            srcDir: ctx.stringOpt("src-dir"),
+            tsconfig: ctx.stringOpt("tsconfig"),
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          process.stderr.write(`${message}\n`);
+          process.exit(1);
+        }
+      },
+    },
   ],
 } satisfies CliProgram;

package/src/cli-tool/run-schemagen.ts

@@ -0,0 +1,23 @@
+/** Run argsbarg schemagen in the current working directory (or `--root`). */
+
+import { resolve } from "node:path";
+import { runSchemagen } from "./schemagen/run.ts";
+
+export interface RunSchemagenCliOptions {
+  root?: string;
+  srcDir?: string;
+  tsconfig?: string;
+}
+
+/** Exit 0 on success; throws on failure. */
+export function runSchemagenCli(options: RunSchemagenCliOptions = {}): void {
+  const projectRoot = resolve(options.root ?? process.cwd());
+  const counts = runSchemagen({
+    projectRoot,
+    srcDir: options.srcDir,
+    tsconfig: options.tsconfig,
+  });
+  console.log(
+    `config roots: ${counts.configRoots}, input roots: ${counts.inputRoots}, output roots: ${counts.outputRoots}`,
+  );
+}

package/src/cli-tool/schemagen/cleanup.ts

@@ -0,0 +1,60 @@
+/*
+Remove stale __generated__/ directories and files after schemagen runs.
+*/
+
+import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import type { SchemaRoot } from "./discover-schema-roots.ts";
+import { GENERATED_DIR, schemaJsonBasename, TYPES_FILE } from "./names.ts";
+
+function listGeneratedDirs(srcDir: string, projectRoot: string, out: string[]): void {
+  for (const ent of readdirSync(srcDir)) {
+    const full = join(srcDir, ent);
+    const st = statSync(full);
+    if (!st.isDirectory()) {
+      continue;
+    }
+    if (ent === GENERATED_DIR) {
+      out.push(relative(projectRoot, full));
+      continue;
+    }
+    listGeneratedDirs(full, projectRoot, out);
+  }
+}
+
+/** Drop orphan `__generated__/` trees and JSON files for removed schema kinds. */
+export function cleanStaleGenerated(
+  projectRoot: string,
+  srcDir: string,
+  activeBySchemaFile: Map<string, SchemaRoot[]>,
+): void {
+  const srcPath = join(projectRoot, srcDir);
+  if (!existsSync(srcPath)) {
+    return;
+  }
+
+  const generatedDirs: string[] = [];
+  listGeneratedDirs(srcPath, projectRoot, generatedDirs);
+
+  for (const relGeneratedDir of generatedDirs) {
+    const generatedDir = join(projectRoot, relGeneratedDir);
+    const relTypesPath = relative(projectRoot, join(dirname(generatedDir), TYPES_FILE));
+    const roots = existsSync(join(projectRoot, relTypesPath)) ? (activeBySchemaFile.get(relTypesPath) ?? []) : [];
+
+    if (roots.length === 0) {
+      rmSync(generatedDir, { recursive: true, force: true });
+      console.log(`removed ${relGeneratedDir}`);
+      continue;
+    }
+
+    const keep = new Set(["index.ts", ...roots.map((root) => schemaJsonBasename(root.kind))]);
+    for (const ent of readdirSync(generatedDir)) {
+      if (keep.has(ent)) {
+        continue;
+      }
+      const stalePath = join(generatedDir, ent);
+      rmSync(stalePath, { recursive: true, force: true });
+      console.log(`removed ${relative(projectRoot, stalePath)}`);
+    }
+  }
+}

package/src/cli-tool/schemagen/discover-schema-roots.ts

@@ -0,0 +1,173 @@
+/*
+Discovers schema roots in types.ts files via configType / inputType / outputType exports.
+*/
+
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { TYPES_FILE } from "./names.ts";
+
+export type SchemaRootKind = "config" | "input" | "output";
+
+export type SchemaRole = "configType" | "inputType" | "outputType";
+
+export interface SchemaRoot {
+  kind: SchemaRootKind;
+  typeName: string;
+  /** Path to types.ts relative to project root (anchors __generated__/ output). */
+  path: string;
+  /** Path to the file that defines `typeName` (defaults to `path`). */
+  sourcePath: string;
+}
+
+const ROLE_EXPORT_RE = /export\s+type\s+(configType|inputType|outputType)\s*=\s*(\w+)/g;
+const HAS_ROLE_EXPORT_RE = /export\s+type\s+(configType|inputType|outputType)\s*=/;
+const IMPORT_RE = /import\s+(?:type\s+)?\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
+
+const ROLE_TO_KIND: Record<SchemaRole, SchemaRootKind> = {
+  configType: "config",
+  inputType: "input",
+  outputType: "output",
+};
+
+function listTypesManifestFiles(srcDir: string, baseDir: string, out: string[]): void {
+  for (const ent of readdirSync(srcDir)) {
+    const full = join(srcDir, ent);
+    const st = statSync(full);
+    if (st.isDirectory()) {
+      listTypesManifestFiles(full, baseDir, out);
+      continue;
+    }
+    if (ent !== TYPES_FILE) {
+      continue;
+    }
+    const text = readFileSync(full, "utf8");
+    if (HAS_ROLE_EXPORT_RE.test(text)) {
+      out.push(relative(baseDir, full));
+    }
+  }
+}
+
+/** True when `typeName` is declared in this file (not a schemagen role alias). */
+function isTypeDefinedInFile(text: string, typeName: string): boolean {
+  if (new RegExp(`export\\s+interface\\s+${typeName}\\b`).test(text)) {
+    return true;
+  }
+  if (new RegExp(`export\\s+type\\s+${typeName}\\s*=`).test(text)) {
+    return !["configType", "inputType", "outputType"].includes(typeName);
+  }
+  return false;
+}
+
+function parseLocalTypeImports(text: string): Map<string, string> {
+  const imports = new Map<string, string>();
+  for (const match of text.matchAll(IMPORT_RE)) {
+    const names = match[1];
+    const from = match[2];
+    if (!names || !from?.startsWith(".")) {
+      continue;
+    }
+    for (const part of names.split(",")) {
+      const trimmed = part.trim();
+      const nameMatch = trimmed.match(/^(?:type\s+)?(\w+)(?:\s+as\s+(\w+))?$/);
+      if (!nameMatch?.[1]) {
+        continue;
+      }
+      const localName = nameMatch[2] ?? nameMatch[1];
+      imports.set(localName, from);
+    }
+  }
+  return imports;
+}
+
+function resolveModuleFile(manifestFile: string, specifier: string): string | null {
+  const base = join(dirname(manifestFile), specifier);
+  const candidates = [base, `${base}.ts`, join(base, "index.ts")];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+/** Resolve a role alias to the module that defines `typeName`, when imported from a relative path. */
+function resolveAliasedTypeSource(
+  projectRoot: string,
+  manifestRelPath: string,
+  manifestText: string,
+  typeName: string,
+): string | null {
+  const manifestFile = join(projectRoot, manifestRelPath);
+  const specifier = parseLocalTypeImports(manifestText).get(typeName);
+  if (!specifier) {
+    return null;
+  }
+  const moduleFile = resolveModuleFile(manifestFile, specifier);
+  if (!moduleFile) {
+    return null;
+  }
+  const moduleText = readFileSync(moduleFile, "utf8");
+  if (!isTypeDefinedInFile(moduleText, typeName)) {
+    return null;
+  }
+  return relative(projectRoot, moduleFile);
+}
+
+function discoverFromFile(projectRoot: string, path: string, text: string): SchemaRoot[] {
+  const rolesSeen = new Set<SchemaRole>();
+  const roots: SchemaRoot[] = [];
+
+  for (const match of text.matchAll(ROLE_EXPORT_RE)) {
+    const role = match[1] as SchemaRole | undefined;
+    const typeName = match[2];
+    if (!role || !typeName) {
+      continue;
+    }
+    if (rolesSeen.has(role)) {
+      throw new Error(`${path}: duplicate export type ${role}`);
+    }
+    rolesSeen.add(role);
+
+    let sourcePath = path;
+    if (!isTypeDefinedInFile(text, typeName)) {
+      const resolved = resolveAliasedTypeSource(projectRoot, path, text, typeName);
+      if (!resolved) {
+        continue;
+      }
+      sourcePath = resolved;
+    }
+
+    roots.push({ kind: ROLE_TO_KIND[role], typeName, path, sourcePath });
+  }
+
+  return roots;
+}
+
+/** Find all schema roots under `srcDir` in `types.ts` files with role exports. */
+export function discoverSchemaRoots(projectRoot: string, srcDir = "src"): SchemaRoot[] {
+  const srcPath = join(projectRoot, srcDir);
+  const files: string[] = [];
+  listTypesManifestFiles(srcPath, projectRoot, files);
+
+  const roots: SchemaRoot[] = [];
+  const typeOwners = new Map<string, string>();
+
+  for (const relPath of files.sort()) {
+    const text = readFileSync(join(projectRoot, relPath), "utf8");
+    for (const root of discoverFromFile(projectRoot, relPath, text)) {
+      const prev = typeOwners.get(root.typeName);
+      if (prev) {
+        throw new Error(`${relPath}: duplicate schema root type ${root.typeName} (already declared in ${prev})`);
+      }
+      typeOwners.set(root.typeName, relPath);
+      roots.push(root);
+    }
+  }
+
+  const configRoots = roots.filter((r) => r.kind === "config");
+  if (configRoots.length > 1) {
+    throw new Error(`multiple config schema roots: ${configRoots.map((r) => `${r.typeName} (${r.path})`).join(", ")}`);
+  }
+
+  return roots;
+}

package/src/cli-tool/schemagen/index.ts

@@ -0,0 +1,3 @@
+export { discoverSchemaRoots, type SchemaRoot, type SchemaRootKind } from "./discover-schema-roots.ts";
+export { GENERATED_DIR, schemaExportName, schemaJsonBasename, TYPES_FILE } from "./names.ts";
+export { type RunSchemagenOptions, type RunSchemagenResult, runSchemagen } from "./run.ts";

package/src/cli-tool/schemagen/names.ts

@@ -0,0 +1,22 @@
+import type { SchemaRootKind } from "./discover-schema-roots.ts";
+
+/** Directory name for generated schema artifacts (next to `types.ts`). */
+export const GENERATED_DIR = "__generated__";
+
+/** TypeScript schemagen manifest filename under `src/`. */
+export const TYPES_FILE = "types.ts";
+
+/** JSON basename for a schema root kind (`outputSchema.json`, etc.). */
+export function schemaJsonBasename(kind: SchemaRootKind): string {
+  return `${kind}Schema.json`;
+}
+
+/** Export const name wired on leaves or `program.appConfig`. */
+export function schemaExportName(kind: SchemaRootKind): string {
+  return `${kind}Schema`;
+}
+
+/** Safe import binding for a schema JSON basename. */
+export function schemaJsonImportVar(kind: SchemaRootKind): string {
+  return `${kind}SchemaJson`;
+}

package/src/cli-tool/schemagen/run.ts

@@ -0,0 +1,109 @@
+/*
+Generate JSON Schema artifacts under __generated__/ and write index.ts re-exports.
+*/
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { createGenerator } from "ts-json-schema-generator";
+import { cleanStaleGenerated } from "./cleanup.ts";
+import { discoverSchemaRoots, type SchemaRoot, type SchemaRootKind } from "./discover-schema-roots.ts";
+import { GENERATED_DIR, schemaExportName, schemaJsonBasename, schemaJsonImportVar } from "./names.ts";
+
+const KIND_ORDER: SchemaRootKind[] = ["config", "input", "output"];
+
+export interface RunSchemagenOptions {
+  /** Project root (default: `process.cwd()`). */
+  projectRoot?: string;
+  /** Source tree directory relative to project root (default: `src`). */
+  srcDir?: string;
+  /** Path to tsconfig relative to project root (default: `tsconfig.json`). */
+  tsconfig?: string;
+}
+
+export interface RunSchemagenResult {
+  configRoots: number;
+  inputRoots: number;
+  outputRoots: number;
+}
+
+function resolveTsconfig(projectRoot: string, tsconfig: string): string {
+  const path = join(projectRoot, tsconfig);
+  try {
+    return path;
+  } catch {
+    throw new Error(`tsconfig not found: ${path}`);
+  }
+}
+
+function generateJson(projectRoot: string, tsconfigPath: string, root: SchemaRoot): Record<string, unknown> {
+  const typeFile = join(projectRoot, root.sourcePath);
+  const generator = createGenerator({
+    path: typeFile,
+    type: root.typeName,
+    tsconfig: tsconfigPath,
+    topRef: false,
+    skipTypeCheck: false,
+    jsDoc: "extended",
+    additionalProperties: root.kind === "config" ? false : undefined,
+  });
+  const schema = generator.createSchema(root.typeName) as Record<string, unknown>;
+  if (root.kind === "config") {
+    schema.additionalProperties = false;
+  }
+  return schema;
+}
+
+function writeGeneratedIndex(generatedDir: string, roots: SchemaRoot[]): void {
+  const sorted = [...roots].sort((left, right) => KIND_ORDER.indexOf(left.kind) - KIND_ORDER.indexOf(right.kind));
+  const lines = ["// Auto-generated by argsbarg schemagen — do not edit by hand.", ""];
+  for (const root of sorted) {
+    lines.push(`import ${schemaJsonImportVar(root.kind)} from "./${schemaJsonBasename(root.kind)}";`);
+  }
+  if (sorted.length > 0) {
+    lines.push("");
+  }
+  for (const root of sorted) {
+    lines.push(
+      `export const ${schemaExportName(root.kind)} = ${schemaJsonImportVar(root.kind)} as Record<string, unknown>;`,
+    );
+    lines.push("");
+  }
+  writeFileSync(join(generatedDir, "index.ts"), `${lines.join("\n")}`);
+}
+
+/** Generate colocated `__generated__` JSON schemas and `index.ts` barrels. */
+export function runSchemagen(options: RunSchemagenOptions = {}): RunSchemagenResult {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const srcDir = options.srcDir ?? "src";
+  const tsconfigPath = resolveTsconfig(projectRoot, options.tsconfig ?? "tsconfig.json");
+
+  const roots = discoverSchemaRoots(projectRoot, srcDir);
+  const bySchemaFile = new Map<string, SchemaRoot[]>();
+
+  for (const root of roots) {
+    const schema = generateJson(projectRoot, tsconfigPath, root);
+    const generatedDir = join(dirname(join(projectRoot, root.path)), GENERATED_DIR);
+    mkdirSync(generatedDir, { recursive: true });
+    const jsonPath = join(generatedDir, schemaJsonBasename(root.kind));
+    writeFileSync(jsonPath, `${JSON.stringify(schema, null, 2)}\n`);
+    console.log(`wrote ${relative(projectRoot, jsonPath)} (${root.typeName})`);
+
+    const list = bySchemaFile.get(root.path) ?? [];
+    list.push(root);
+    bySchemaFile.set(root.path, list);
+  }
+
+  for (const [relPath, fileRoots] of bySchemaFile) {
+    const generatedDir = join(dirname(join(projectRoot, relPath)), GENERATED_DIR);
+    writeGeneratedIndex(generatedDir, fileRoots);
+    console.log(`wrote ${relative(projectRoot, join(generatedDir, "index.ts"))}`);
+  }
+
+  cleanStaleGenerated(projectRoot, srcDir, bySchemaFile);
+
+  return {
+    configRoots: roots.filter((r) => r.kind === "config").length,
+    inputRoots: roots.filter((r) => r.kind === "input").length,
+    outputRoots: roots.filter((r) => r.kind === "output").length,
+  };
+}