@ozzylabs/feedradar 0.1.4 → 0.1.6

package/dist/cli/source.js

@@ -1,6 +1,8 @@
 import { access, readdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { createProgressReporter } from "../core/progress.js";
+import { listRecipes, loadRecipe, mergeRecipeWithOverrides, } from "../core/recipes.js";
 import { loadSourceState } from "../core/state.js";
 import { watchRun } from "../core/watcher.js";
 import { SourceKindSchema, SourceSchema, SourceSelectorsSchema } from "../schemas/source.js";
@@ -40,6 +42,35 @@ function splitCsv(value) {
         .map((s) => s.trim())
         .filter((s) => s.length > 0);
 }
+/**
+ * Parse an `--<option> N` integer argument with a configurable minimum.
+ *
+ * Used for `--pagination-page-size` / `--max-pages` / etc. where Zod will
+ * also validate the resulting Source object, but throwing here means the
+ * user sees a single targeted error referencing the flag name they typed
+ * instead of a deeper schema-path message.
+ *
+ * `min` defaults to 1 because every json-api pagination integer the schema
+ * accepts is `z.number().int().positive()`; the `--pagination-start` flag
+ * passes `min: 0` for offset/page indices that legitimately begin at 0.
+ */
+function parseIntFlag(flag, raw, min) {
+    if (raw === undefined)
+        throw new Error(`option ${flag} requires a value`);
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < min) {
+        throw new Error(`option ${flag} expects an integer >= ${min}, got '${raw}'`);
+    }
+    return n;
+}
+/**
+ * Pagination strategies accepted by `--pagination-strategy` on
+ * `radar source add --kind json-api`. Mirrors `SourcePaginationSchema.type`
+ * — kept as a local const so the CLI validator emits a user-friendly enum
+ * list before Zod runs (Zod surfaces the same set, but a leading "did you
+ * mean …?" message at the CLI layer reads better in shell context).
+ */
+const PAGINATION_STRATEGIES = ["page", "offset", "cursor", "link-header", "token", "none"];
 /**
  * Parse `source add` flags.
  *
@@ -62,6 +93,13 @@ function parseAddArgs(args) {
             out.url = args[++i];
             continue;
         }
+        if (a === "--recipe") {
+            const value = args[++i];
+            if (value === undefined)
+                throw new Error(`option ${a} requires a value`);
+            out.recipe = value;
+            continue;
+        }
         if (a === "--name") {
             out.name = args[++i];
             continue;
@@ -94,6 +132,56 @@ function parseAddArgs(args) {
             out.selectors[field] = value;
             continue;
         }
+        if (a === "--pagination-strategy") {
+            const value = args[++i];
+            if (value === undefined)
+                throw new Error(`option ${a} requires a value`);
+            if (!PAGINATION_STRATEGIES.includes(value)) {
+                throw new Error(`option --pagination-strategy expects one of: ${PAGINATION_STRATEGIES.join(" | ")}, got '${value}'`);
+            }
+            out.paginationStrategy = value;
+            continue;
+        }
+        if (a === "--pagination-param") {
+            const value = args[++i];
+            if (value === undefined)
+                throw new Error(`option ${a} requires a value`);
+            out.paginationParam = value;
+            continue;
+        }
+        if (a === "--pagination-start") {
+            out.paginationStart = parseIntFlag(a, args[++i], 0);
+            continue;
+        }
+        if (a === "--page-size") {
+            out.paginationPageSize = parseIntFlag(a, args[++i], 1);
+            continue;
+        }
+        if (a === "--page-size-param") {
+            const value = args[++i];
+            if (value === undefined)
+                throw new Error(`option ${a} requires a value`);
+            out.paginationPageSizeParam = value;
+            continue;
+        }
+        if (a === "--max-pages") {
+            out.paginationMaxPages = parseIntFlag(a, args[++i], 1);
+            continue;
+        }
+        if (a === "--next-cursor-path") {
+            const value = args[++i];
+            if (value === undefined)
+                throw new Error(`option ${a} requires a value`);
+            out.paginationNextCursorPath = value;
+            continue;
+        }
+        if (a === "--total-path") {
+            const value = args[++i];
+            if (value === undefined)
+                throw new Error(`option ${a} requires a value`);
+            out.paginationTotalPath = value;
+            continue;
+        }
         if (a?.startsWith("--")) {
             throw new Error(`unknown option: ${a}`);
         }
@@ -154,6 +242,14 @@ function parseTestArgs(args) {
             out.showContent = true;
             continue;
         }
+        if (a === "--verbose" || a === "-v") {
+            out.verbose = true;
+            continue;
+        }
+        if (a === "--quiet" || a === "-q") {
+            out.quiet = true;
+            continue;
+        }
         if (a?.startsWith("--")) {
             throw new Error(`unknown option: ${a}`);
         }
@@ -163,6 +259,9 @@ function parseTestArgs(args) {
         }
         throw new Error(`unexpected positional argument: ${a}`);
     }
+    if (out.verbose && out.quiet) {
+        throw new Error("--verbose and --quiet are mutually exclusive");
+    }
     return out;
 }
 function parseRemoveArgs(args) {
@@ -185,10 +284,15 @@ function parseRemoveArgs(args) {
 }
 function printAddHelp(log) {
     log("Usage: radar source add <id> --kind <kind> --url <url> [options]");
+    log("       radar source add <id> --recipe <name> [overrides]");
     log("");
     log("Options:");
-    log("  --kind <kind>            rss | html | html-js | github-releases | npm-registry");
+    log("  --kind <kind>            rss | html | html-js | github-releases | npm-registry | json-feed | json-api");
     log("  --url <url>              fetch target URL");
+    log("  --recipe <name>          apply a bundled recipe (see `radar source recipes`).");
+    log("                           Mutually exclusive with --kind / --url / --selector-* /");
+    log("                           --pagination-*; --name / --tags / --keywords /");
+    log("                           --exclude-keywords still override the recipe defaults.");
     log("  --name <name>            display name (defaults to <id>)");
     log("  --tags <a,b>             comma-separated tags");
     log("  --keywords <a,b>         comma-separated include keywords");
@@ -199,6 +303,24 @@ function printAddHelp(log) {
     log("                           For kind=html-js, selectors evaluate against the post-JS DOM.");
     log("                           The `js:` block (waitFor / timeout / userAgent) cannot be set");
     log("                           via flags; edit sources/<id>.yaml after add. See ADR-0010.");
+    log("");
+    log("  For kind=json-api (ADR-0012 / #174):");
+    log("    --pagination-strategy <s>  page | offset | cursor | link-header | token | none (default: page)");
+    log("    --pagination-param <name>  query param name for the page/offset/cursor value");
+    log("    --pagination-start N       initial page/offset value (default: 0)");
+    log("    --page-size N              items per page");
+    log("    --page-size-param <name>   query param name for the page-size value");
+    log("    --max-pages N              hard cap on pages traversed (default: 20)");
+    log("    --next-cursor-path <jp>    JSONPath-lite to the next-cursor value (cursor/token strategy)");
+    log("    --total-path <jp>          JSONPath-lite to the total-count value (backfill early-stop hint)");
+    log("");
+    log("  Selector fields (`jsonSelectors.*`) for kind=json-api cannot be set via flags;");
+    log("  the schema has a default fallback chain (items / title / link / publishedAt / summary),");
+    log("  so simple APIs work without selectors. Edit sources/<id>.yaml directly when explicit");
+    log("  selectors are needed (nested fields, non-standard envelopes).");
+    log("");
+    log("  Facet sweep (e.g. year-by-year sweep) cannot be configured via flags; see ADR-0017");
+    log("  and bundle the year sweep through `--recipe aws-whats-new`. Recipe-only structural field.");
 }
 function printListHelp(log) {
     log("Usage: radar source list [--enabled-only] [-v|--verbose]");
@@ -222,16 +344,42 @@ function printTestHelp(log) {
     log("state/ and items/ are not touched (no persistence). Useful for tuning");
     log("keywords when adding a new source.");
     log("");
+    log("For kind=json-api (ADR-0012 / #174), `source test` fetches PAGE 0 ONLY.");
+    log("Pagination is NOT walked even when the recipe declares multiple pages —");
+    log("`--limit N` caps how many matched items are PRINTED, it does not change");
+    log("the page budget. Use `radar watch run --backfill` for full-history ingest.");
+    log("Page 0's `Link` header / `nextCursor` extraction is surfaced via");
+    log("`--show-content` for pagination tuning without state mutation.");
+    log("");
     log("Options:");
     log("  --limit N        Maximum number of matched items to print (default 10)");
-    log("  --show-content   Also print the first 200 characters of each item's body");
+    log("  --show-content   Also print the first 200 chars of each item's body, plus");
+    log("                   (kind=json-api) the selector adoption table and pagination");
+    log("                   preview (would-be next URL / Link header / nextCursor).");
+    log("  -v, --verbose    Enable progress-reporter raw() pass-through (adapter stdout).");
+    log("                   Most useful with kind=html-js (Playwright phase markers).");
+    log("  -q, --quiet      Suppress the progress reporter entirely. RADAR_NO_PROGRESS=1");
+    log("                   has the same effect.");
+}
+function printRecipesHelp(log) {
+    log("Usage: radar source recipes");
+    log("");
+    log("List bundled recipes (recipes/*.yaml in the radar package — ADR-0012 §D3).");
+    log("Each recipe can be applied via:");
+    log("  radar source add <id> --recipe <name> [--keywords <kw>] [--tags <t>] [--name <display>]");
+    log("");
+    log("Bundled recipes ship with the radar npm package; user-authored recipes are");
+    log("not yet supported. To add a new bundled recipe, contribute a YAML to the");
+    log("radar repo's recipes/ directory.");
 }
 function printSourceHelp(log) {
-    log("Usage: radar source <add|list|remove|test> [...]");
+    log("Usage: radar source <add|list|recipes|remove|test> [...]");
     log("");
     log("Subcommands:");
     log("  add <id> --kind <kind> --url <url> [...]");
+    log("  add <id> --recipe <name> [--keywords <kw>] [--tags <t>] [--name <display>]");
     log("  list [--enabled-only]");
+    log("  recipes");
     log("  remove <id>");
     log("  test <id> [--limit N] [--show-content]");
 }
@@ -269,6 +417,16 @@ export async function addSource(args, options = {}) {
         error(`source add: invalid <id> '${parsed.id}' (must match [A-Za-z0-9][A-Za-z0-9._-]*)`);
         return 2;
     }
+    // `--recipe <name>` short-circuits the flag-based composition: the
+    // recipe supplies kind / url / pagination / selectors / etc., and only
+    // a narrow whitelist of CLI flags is allowed to override
+    // (`--name` / `--tags` / `--keywords` / `--exclude-keywords`).
+    // Everything else (incl. `--kind` / `--url` / `--selector-*` /
+    // `--pagination-*`) is rejected so the user gets an immediate, targeted
+    // error instead of silently-ignored flags. ADR-0012 §D3.
+    if (parsed.recipe !== undefined) {
+        return addSourceFromRecipe(parsed, cwd, options, log, warn, error);
+    }
     if (!parsed.kind) {
         error("source add: --kind is required");
         return 2;
@@ -279,7 +437,7 @@ export async function addSource(args, options = {}) {
     }
     const kindResult = SourceKindSchema.safeParse(parsed.kind);
     if (!kindResult.success) {
-        error(`source add: invalid --kind '${parsed.kind}' (expected: rss | html | html-js | github-releases | npm-registry)`);
+        error(`source add: invalid --kind '${parsed.kind}' (expected: rss | html | html-js | github-releases | npm-registry | json-feed | json-api)`);
         return 2;
     }
     // Compose the object before schema validation so url-format errors et al.
@@ -318,6 +476,52 @@ export async function addSource(args, options = {}) {
         }
         candidate.selectors = selectorsResult.data;
     }
+    // For kind=json-api, build the `pagination:` block from --pagination-*
+    // flags. The schema requires `pagination` for this kind; if the user
+    // omitted --pagination-strategy entirely we default to `page` (the most
+    // common shape for AWS What's New / dev.to / Anthropic news). We do NOT
+    // generate a `jsonSelectors:` block — the default fallback chain covers
+    // simple APIs, and recipe authors edit the YAML directly when explicit
+    // selectors are needed (the field count makes flag-based mutation
+    // impractical).
+    if (kindResult.data === "json-api") {
+        const strategy = parsed.paginationStrategy ?? "page";
+        const pagination = { type: strategy };
+        if (parsed.paginationParam !== undefined)
+            pagination.param = parsed.paginationParam;
+        if (parsed.paginationStart !== undefined)
+            pagination.start = parsed.paginationStart;
+        if (parsed.paginationPageSize !== undefined) {
+            pagination.pageSize = parsed.paginationPageSize;
+        }
+        if (parsed.paginationPageSizeParam !== undefined) {
+            pagination.pageSizeParam = parsed.paginationPageSizeParam;
+        }
+        if (parsed.paginationMaxPages !== undefined) {
+            pagination.maxPages = parsed.paginationMaxPages;
+        }
+        if (parsed.paginationNextCursorPath !== undefined) {
+            pagination.nextCursorPath = parsed.paginationNextCursorPath;
+        }
+        if (parsed.paginationTotalPath !== undefined) {
+            pagination.totalPath = parsed.paginationTotalPath;
+        }
+        candidate.pagination = pagination;
+    }
+    else if (parsed.paginationStrategy !== undefined ||
+        parsed.paginationParam !== undefined ||
+        parsed.paginationStart !== undefined ||
+        parsed.paginationPageSize !== undefined ||
+        parsed.paginationPageSizeParam !== undefined ||
+        parsed.paginationMaxPages !== undefined ||
+        parsed.paginationNextCursorPath !== undefined ||
+        parsed.paginationTotalPath !== undefined) {
+        // Reject pagination flags on non-json-api kinds early so the user sees
+        // a targeted hint instead of a deep schema refinement error ("pagination
+        // is required when kind is 'json-api'" makes no sense for `kind: rss`).
+        error(`source add: --pagination-* flags are only valid with --kind json-api (got --kind '${kindResult.data}')`);
+        return 2;
+    }
     const validated = SourceSchema.safeParse(candidate);
     if (!validated.success) {
         const issues = validated.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`);
@@ -346,6 +550,104 @@ export async function addSource(args, options = {}) {
     }
     return 0;
 }
+/**
+ * Apply a bundled recipe (`--recipe <name>`) to produce a new
+ * `sources/<id>.yaml` (ADR-0012 §D3, strategy A).
+ *
+ * Validation discipline:
+ *
+ * - The recipe supplies `kind` / `url` / structural fields. Re-passing
+ *   them as CLI flags is rejected to prevent the "recipe says one thing,
+ *   flag says another, who wins?" footgun. Only the explicit override
+ *   whitelist (`--name` / `--tags` / `--keywords` /
+ *   `--exclude-keywords`) is honoured.
+ * - `--selector-*` / `--pagination-*` are also rejected on the recipe
+ *   path — these belong to the recipe author. Users who want to deviate
+ *   structurally edit `sources/<id>.yaml` after generation, same as for
+ *   any other source.
+ */
+async function addSourceFromRecipe(parsed, cwd, options, log, warn, error) {
+    const recipeName = parsed.recipe;
+    // Defensive — should be guaranteed by the caller, but `parsed.recipe`
+    // is typed as `string | undefined` so a quick narrow here keeps the
+    // rest of the function tidy.
+    if (recipeName === undefined) {
+        error("source add: --recipe is required (internal dispatch error)");
+        return 2;
+    }
+    // Reject flags that the recipe owns. Surfacing each forbidden flag
+    // individually beats a generic "incompatible flags" message because
+    // the user sees exactly what to remove.
+    const forbidden = [];
+    if (parsed.kind !== undefined)
+        forbidden.push("--kind");
+    if (parsed.url !== undefined)
+        forbidden.push("--url");
+    if (parsed.selectors !== undefined)
+        forbidden.push("--selector-<field>");
+    if (parsed.paginationStrategy !== undefined ||
+        parsed.paginationParam !== undefined ||
+        parsed.paginationStart !== undefined ||
+        parsed.paginationPageSize !== undefined ||
+        parsed.paginationPageSizeParam !== undefined ||
+        parsed.paginationMaxPages !== undefined ||
+        parsed.paginationNextCursorPath !== undefined ||
+        parsed.paginationTotalPath !== undefined) {
+        forbidden.push("--pagination-*");
+    }
+    if (forbidden.length > 0) {
+        error(`source add: --recipe '${recipeName}' supplies kind / url / structural fields; the following flags are not allowed with --recipe: ${forbidden.join(", ")}`);
+        return 2;
+    }
+    let loaded;
+    try {
+        loaded = await loadRecipe(recipeName, { recipesRoot: options.recipesRoot });
+    }
+    catch (e) {
+        error(`source add: ${e instanceof Error ? e.message : String(e)}`);
+        return 1;
+    }
+    const candidate = mergeRecipeWithOverrides(loaded.recipe, {
+        // `parsed.id` is asserted non-undefined by the caller before this
+        // function is reached, but TypeScript cannot see that across the
+        // dispatch boundary. The non-null assertion mirrors what the
+        // flag-based path expects from the same guard.
+        // biome-ignore lint/style/noNonNullAssertion: caller-enforced invariant
+        id: parsed.id,
+        name: parsed.name,
+        tags: parsed.tags,
+        keywords: parsed.keywords,
+        excludeKeywords: parsed.excludeKeywords,
+    });
+    const validated = SourceSchema.safeParse(candidate);
+    if (!validated.success) {
+        // A Zod failure on a recipe-derived candidate means the recipe
+        // itself is malformed (or, more rarely, an override produced an
+        // illegal combination). Surface every issue verbatim so recipe
+        // authors and end users can both diagnose.
+        const issues = validated.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`);
+        error(`source add: recipe '${recipeName}' produced an invalid source`);
+        for (const issue of issues) {
+            error(`  - ${issue}`);
+        }
+        return 2;
+    }
+    const file = sourceFile(cwd, validated.data.id);
+    if (await pathExists(file)) {
+        error(`source add: '${validated.data.id}' already exists (sources/${validated.data.id}.yaml)`);
+        return 1;
+    }
+    await writeFile(file, stringifyYaml(validated.data), "utf8");
+    log(`source add: created sources/${validated.data.id}.yaml from recipe '${recipeName}'`);
+    // Same firehose-guard hint as the flag-based path: an empty
+    // include-keyword list silently drops every fetched item, which
+    // surprises users when they thought the recipe came with sensible
+    // defaults.
+    if (validated.data.filters.keywords.length === 0) {
+        warn(`source add: warning — '${validated.data.id}' has no keywords; all fetched items will be filtered out. Re-add with --keywords or edit sources/${validated.data.id}.yaml to start ingesting.`);
+    }
+    return 0;
+}
 /**
  * Load and validate a single `sources/<id>.yaml` file. Returns `null` and
  * reports through `onError` when the file is malformed, so `list` can keep
@@ -592,6 +894,13 @@ export async function testSource(args, options = {}) {
         return 1;
     }
     const limit = parsed.limit ?? 10;
+    // Build the progress reporter (#198). `source test` runs exactly one
+    // source so the watcher heuristic only enables narration when the kind
+    // is `html-js` / `json-api`; for rss / html / npm-registry / etc. the
+    // legacy 1-line summary remains the only output. Tests pin the level
+    // explicitly via `--quiet` or `RADAR_NO_PROGRESS=1`.
+    const level = parsed.quiet ? "quiet" : parsed.verbose ? "verbose" : "normal";
+    const progress = createProgressReporter({ level });
     let result;
     try {
         result = await watchRun({
@@ -602,6 +911,7 @@ export async function testSource(args, options = {}) {
             log,
             warn,
             error,
+            progress,
         });
     }
     catch (e) {
@@ -620,6 +930,41 @@ export async function testSource(args, options = {}) {
     log("");
     log(`source test: ${parsed.id}`);
     log(`  fetched: ${fetched} / filtered: ${filtered} / matched: ${matched.length}`);
+    // Render the adapter diag for `kind: json-api` when --show-content is on.
+    // The diag block is intentionally gated behind --show-content so the
+    // default `source test` output (used by scripts that just want a quick
+    // matched-items dump) stays narrow. Adapters that do not return diag
+    // simply skip this block.
+    if (parsed.showContent) {
+        const diag = result.diag[parsed.id];
+        if (diag) {
+            if (diag.selectorAdoption) {
+                log("");
+                log("  selector adoption:");
+                for (const [field, path] of Object.entries(diag.selectorAdoption)) {
+                    if (path === null) {
+                        log(`    ${field}: (no candidate matched)`);
+                    }
+                    else {
+                        log(`    ${field} ← ${path} を採用`);
+                    }
+                }
+            }
+            if (diag.paginationPreview) {
+                const p = diag.paginationPreview;
+                log("");
+                log("  pagination preview (page 0 only — state not mutated):");
+                log(`    strategy:  ${p.strategy}`);
+                log(`    nextUrl:   ${p.nextUrl ?? "(end of pagination)"}`);
+                if (p.linkHeaderNext !== undefined) {
+                    log(`    Link rel=next: ${p.linkHeaderNext ?? "(absent)"}`);
+                }
+                if (p.nextCursor !== undefined) {
+                    log(`    nextCursor: ${p.nextCursor ?? "(absent)"}`);
+                }
+            }
+        }
+    }
     if (matched.length === 0) {
         log("  (no matched items)");
         return 0;
@@ -650,12 +995,86 @@ export async function testSource(args, options = {}) {
     }
     return 0;
 }
+/**
+ * Implementation of `source recipes` — list bundled recipes.
+ *
+ * Prints a fixed-width table (NAME / KIND / DESCRIPTION) for each
+ * `recipes/<name>.yaml` that loads cleanly. Recipes that fail to parse
+ * are appended after the valid set with their error so the user can fix
+ * (or report) the recipe without losing the rest of the listing.
+ *
+ * When the bundle is empty or absent (the bootstrap state before #178
+ * ships the actual recipe content), a friendly "no recipes" message is
+ * printed and exit code 0 is returned — the CLI is functional even when
+ * the recipe library is empty.
+ */
+export async function recipesSubcommand(args, options = {}) {
+    const log = options.io?.log ?? ((m) => console.log(m));
+    const error = options.io?.error ?? ((m) => console.error(m));
+    // The only flag accepted today is `-h` / `--help`. Keep the parser
+    // tiny rather than introducing a typed args struct for a single
+    // option — easier to extend if/when filters land.
+    for (const a of args) {
+        if (a === "-h" || a === "--help") {
+            printRecipesHelp(log);
+            return 0;
+        }
+        if (a.startsWith("--")) {
+            error(`source recipes: unknown option: ${a}`);
+            return 2;
+        }
+        error(`source recipes: unexpected positional argument: ${a}`);
+        return 2;
+    }
+    let entries;
+    try {
+        entries = await listRecipes({ recipesRoot: options.recipesRoot });
+    }
+    catch (e) {
+        error(`source recipes: ${e instanceof Error ? e.message : String(e)}`);
+        return 1;
+    }
+    if (entries.length === 0) {
+        log("source recipes: no recipes bundled (recipes/ is empty or absent)");
+        return 0;
+    }
+    const valid = entries.filter((e) => e.recipe !== null);
+    const invalid = entries.filter((e) => e.recipe === null);
+    if (valid.length > 0) {
+        const nameWidth = Math.max(4, ...valid.map((e) => e.name.length));
+        const kindWidth = Math.max(4, ...valid.map((e) => (e.recipe ? e.recipe.kind.length : 0)));
+        log(`${pad("NAME", nameWidth)}  ${pad("KIND", kindWidth)}  DESCRIPTION`);
+        for (const e of valid) {
+            if (!e.recipe)
+                continue;
+            const desc = e.recipe.description ?? "";
+            log(`${pad(e.name, nameWidth)}  ${pad(e.recipe.kind, kindWidth)}  ${desc}`);
+        }
+    }
+    else {
+        log("source recipes: no valid recipes found (all bundled entries failed to load)");
+    }
+    if (invalid.length > 0) {
+        log("");
+        log("Recipes with errors:");
+        for (const e of invalid) {
+            log(`  ${e.name}: ${e.error ?? "(unknown error)"}`);
+        }
+    }
+    log("");
+    log("Apply a recipe with:");
+    log("  radar source add <id> --recipe <name> [--keywords <kw>] [--tags <t>] [--name <display>]");
+    // Returning 0 even when individual recipes have errors keeps the
+    // listing useful in CI: a single malformed recipe should not break
+    // the discovery command for the rest of the bundle.
+    return 0;
+}
 /**
  * Top-level dispatcher for `radar source <subcommand>`.
  *
  * Sub-commands are kept as named functions (addSource/listSources/removeSource/
- * testSource) so tests can call them directly with injected IO sinks without
- * spawning the full CLI.
+ * testSource/recipesSubcommand) so tests can call them directly with injected
+ * IO sinks without spawning the full CLI.
  */
 export async function runSource(args, options = {}) {
     const log = options.io?.log ?? ((m) => console.log(m));
@@ -670,6 +1089,8 @@ export async function runSource(args, options = {}) {
             return addSource(rest, options);
         case "list":
             return listSources(rest, options);
+        case "recipes":
+            return recipesSubcommand(rest, options);
         case "remove":
             return removeSource(rest, options);
         case "test":
@@ -682,7 +1103,7 @@ export async function runSource(args, options = {}) {
 }
 export const sourceCommand = {
     name: "source",
-    summary: "Manage feed sources (add | list | remove | test)",
+    summary: "Manage feed sources (add | list | recipes | remove | test)",
     run: (args) => runSource(args),
 };
 //# sourceMappingURL=source.js.map