edsger 0.67.0 → 0.69.0

package/dist/api/github.d.ts

@@ -50,6 +50,29 @@ export declare function getGitHubConfigByProduct(productId: string, verbose?: bo
     repo?: string;
     message?: string;
 }>;
+export interface RepositoryBasics {
+    teamId: string | null;
+    fullName: string | null;
+    description: string | null;
+}
+/**
+ * Fetch a repository row's team_id, full_name and description (RLS-scoped).
+ * Used by repo-scoped analysis to resolve the team (recipes are team-scoped)
+ * and to build prompt "product basics" from the repo instead of a product.
+ */
+export declare function getRepositoryBasics(repositoryId: string): Promise<RepositoryBasics>;
+/**
+ * Get GitHub config and token by repository ID (no product / issue required).
+ * Used for repo-scoped analysis (quality-benchmark / recipes / flows running
+ * against a single `repositories` row with no product context).
+ */
+export declare function getGitHubConfigByRepository(repositoryId: string, verbose?: boolean): Promise<{
+    configured: boolean;
+    token?: string;
+    owner?: string;
+    repo?: string;
+    message?: string;
+}>;
 /**
  * Get GitHub config and token in one call
  * This is the main entry point for getting GitHub config

package/dist/api/github.js

@@ -2,6 +2,7 @@
  * GitHub API client for accessing GitHub via MCP server
  * Uses product developer configuration from the database
  */
+import { getSupabase } from '../supabase/client.js';
 import { logDebug, logError, logSuccess, logWarning } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
 /**
@@ -98,6 +99,66 @@ export async function getGitHubConfigByProduct(productId, verbose) {
         };
     }
 }
+/**
+ * Fetch a repository row's team_id, full_name and description (RLS-scoped).
+ * Used by repo-scoped analysis to resolve the team (recipes are team-scoped)
+ * and to build prompt "product basics" from the repo instead of a product.
+ */
+export async function getRepositoryBasics(repositoryId) {
+    const { data } = await getSupabase()
+        .from('repositories')
+        .select('team_id, full_name, description')
+        .eq('id', repositoryId)
+        .maybeSingle();
+    return {
+        teamId: data?.team_id ?? null,
+        fullName: data?.full_name ?? null,
+        description: data?.description ?? null,
+    };
+}
+/**
+ * Get GitHub config and token by repository ID (no product / issue required).
+ * Used for repo-scoped analysis (quality-benchmark / recipes / flows running
+ * against a single `repositories` row with no product context).
+ */
+export async function getGitHubConfigByRepository(repositoryId, verbose) {
+    logDebug(`Fetching GitHub config for repository: ${repositoryId}`, verbose);
+    try {
+        const result = (await callMcpEndpoint('github/config_and_token_by_repository', {
+            repository_id: repositoryId,
+        }));
+        if (verbose) {
+            if (result.configured) {
+                logSuccess(`GitHub ready: ${result.repository_full_name}`);
+            }
+            else {
+                logWarning(`GitHub not configured: ${result.message}`);
+            }
+        }
+        if (result.configured && result.token && result.owner && result.repo) {
+            return {
+                configured: true,
+                token: result.token,
+                owner: result.owner,
+                repo: result.repo,
+            };
+        }
+        return {
+            configured: false,
+            message: result.message ||
+                'GitHub not configured for this repository. Connect the repo first.',
+        };
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to get GitHub config for repository: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return {
+            configured: false,
+            message: error instanceof Error ? error.message : 'Failed to get GitHub config',
+        };
+    }
+}
 /**
  * Get GitHub config and token in one call
  * This is the main entry point for getting GitHub config

package/dist/commands/data-flow/index.d.ts

@@ -11,7 +11,9 @@
  */
 export interface DataFlowCliOptions {
     flowId: string;
+    /** Repo-only mode: generate against a single repositories row, no product. */
+    repoId?: string;
     guidance?: string;
     verbose?: boolean;
 }
-export declare function runDataFlow(productId: string, options: DataFlowCliOptions): Promise<void>;
+export declare function runDataFlow(productId: string | undefined, options: DataFlowCliOptions): Promise<void>;

package/dist/commands/data-flow/index.js

@@ -13,18 +13,27 @@ import { runDataFlowPhase } from '../../phases/data-flow/index.js';
 import { deregisterSession, registerSession, } from '../../system/session-manager.js';
 import { logError, logInfo, logSuccess } from '../../utils/logger.js';
 export async function runDataFlow(productId, options) {
-    const { flowId, guidance, verbose } = options;
-    if (!productId) {
-        throw new Error('Product ID is required for data-flow');
+    const { flowId, repoId, guidance, verbose } = options;
+    if (!productId && !repoId) {
+        throw new Error('Either a product ID or --repo-id is required for data-flow');
     }
     if (!flowId) {
         throw new Error('--flow-id is required (the pending flows row id)');
     }
-    await registerSession({ command: 'data-flow', productId });
-    logInfo(`Starting data flow generation for product ${productId}`);
+    await registerSession({
+        command: 'data-flow',
+        ...(productId ? { productId } : {}),
+    });
+    if (productId) {
+        logInfo(`Starting data flow generation for product ${productId}`);
+    }
+    else {
+        logInfo(`Starting data flow generation for repository ${repoId}`);
+    }
     try {
         const result = await runDataFlowPhase({
             productId,
+            repoId,
             flowId,
             guidance,
             verbose,

package/dist/commands/quality-benchmark/index.js

@@ -25,7 +25,7 @@
  */
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
-import { getGitHubConfigByProduct } from '../../api/github.js';
+import { getGitHubConfigByProduct, getGitHubConfigByRepository, getRepositoryBasics, } from '../../api/github.js';
 import { callMcpEndpoint } from '../../api/mcp-client.js';
 import { fetchProductBasics } from '../../phases/find-shared/mcp.js';
 import { runQualityBenchmark, } from '../../phases/quality-benchmark/index.js';
@@ -34,15 +34,46 @@ import { getSupabase } from '../../supabase/client.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
 export async function runQualityBenchmarkCli(productId, options) {
     const installEnabled = options.install !== false;
-    logInfo(`Starting quality benchmark for product ${productId}`);
+    // Repo-only mode: no product context, benchmark a single repositories row.
+    const repoOnly = !productId && Boolean(options.repoId);
+    if (repoOnly) {
+        logInfo(`Starting quality benchmark for repository ${options.repoId}`);
+    }
+    else {
+        logInfo(`Starting quality benchmark for product ${productId}`);
+    }
     let repoRoot;
     let resolvedBranch;
     // Recorded on the report so it's scoped to the repo that was benchmarked.
     let repositoryId = options.repoId ?? null;
+    // Display name used on the prompt + report (repo full_name in repo-only mode).
+    let productName = productId;
     if (options.repo) {
         repoRoot = resolve(options.repo);
         resolvedBranch = options.branch;
         logInfo(`Repo (override): ${repoRoot}`);
+        if (repoOnly) {
+            const basics = await getRepositoryBasics(options.repoId).catch(() => null);
+            productName = basics?.fullName ?? options.repoId;
+        }
+    }
+    else if (repoOnly) {
+        const gh = await getGitHubConfigByRepository(options.repoId, options.verbose);
+        if (!gh.configured || !gh.token || !gh.owner || !gh.repo) {
+            logError(`Cannot run quality benchmark: ${gh.message ??
+                'GitHub is not configured for this repository. Connect the repo first.'}`);
+            process.exit(1);
+        }
+        const ws = prepareQualityWorkspace({
+            owner: gh.owner,
+            repo: gh.repo,
+            token: gh.token,
+            verbose: options.verbose,
+        });
+        repoRoot = ws.repoPath;
+        resolvedBranch = options.branch ?? ws.branch;
+        productName = `${gh.owner}/${gh.repo}`;
+        logInfo(`Repo: ${repoRoot} (branch: ${resolvedBranch})`);
     }
     else {
         const gh = await getGitHubConfigByProduct(productId, options.verbose);
@@ -82,10 +113,12 @@ export async function runQualityBenchmarkCli(productId, options) {
     if (!installEnabled) {
         logWarning('Install consent NOT granted (--no-install). Missing tools will be marked unmeasured.');
     }
-    const basics = await fetchProductBasics(productId).catch(() => ({
-        name: productId,
-    }));
-    const productName = basics.name;
+    if (!repoOnly) {
+        const basics = await fetchProductBasics(productId).catch(() => ({
+            name: productId,
+        }));
+        productName = basics.name;
+    }
     const onProgress = (event) => {
         if (options.verbose) {
             logInfo(`[${event.phase}] ${event.message}`);
@@ -100,7 +133,7 @@ export async function runQualityBenchmarkCli(productId, options) {
         }
     };
     const outcome = await runQualityBenchmark({
-        productId,
+        productId: repoOnly ? '' : productId,
         productName,
         repoRoot,
         branch: resolvedBranch,
@@ -121,7 +154,8 @@ export async function runQualityBenchmarkCli(productId, options) {
         resolve(process.cwd(), `quality-report-${outcome.commitSha.slice(0, 8)}.json`);
     const reportEnvelope = {
         run_id: outcome.runId,
-        product_id: productId,
+        product_id: repoOnly ? null : productId,
+        repository_id: repositoryId,
         commit_sha: outcome.commitSha,
         branch: resolvedBranch ?? null,
         started_at: outcome.startedAt,
@@ -136,7 +170,7 @@ export async function runQualityBenchmarkCli(productId, options) {
     if (options.save !== false) {
         try {
             const saved = (await callMcpEndpoint('quality_reports/save', {
-                product_id: productId,
+                product_id: repoOnly ? null : productId,
                 repository_id: repositoryId,
                 commit_sha: outcome.commitSha,
                 rubric_version: outcome.report.rubric_version,

package/dist/commands/recipes/index.d.ts

@@ -9,7 +9,9 @@
  */
 export interface RecipesCliOptions {
     scanId: string;
+    /** Repo-only mode: scan a single repositories row with no product context. */
+    repoId?: string;
     guidance?: string;
     verbose?: boolean;
 }
-export declare function runRecipes(productId: string, options: RecipesCliOptions): Promise<void>;
+export declare function runRecipes(productId: string | undefined, options: RecipesCliOptions): Promise<void>;

package/dist/commands/recipes/index.js

@@ -10,16 +10,22 @@
 import { runRecipesPhase } from '../../phases/recipes/index.js';
 import { logError, logInfo, logSuccess } from '../../utils/logger.js';
 export async function runRecipes(productId, options) {
-    const { scanId, guidance, verbose } = options;
-    if (!productId) {
-        throw new Error('Product ID is required for recipes');
+    const { scanId, repoId, guidance, verbose } = options;
+    if (!productId && !repoId) {
+        throw new Error('Either a product ID or --repo-id is required for recipes');
     }
     if (!scanId) {
         throw new Error('--scan-id is required (the pending recipe_scans row id)');
     }
-    logInfo(`Starting recipes scan for product ${productId}`);
+    if (productId) {
+        logInfo(`Starting recipes scan for product ${productId}`);
+    }
+    else {
+        logInfo(`Starting recipes scan for repository ${repoId}`);
+    }
     const result = await runRecipesPhase({
         productId,
+        repoId,
         scanId,
         guidance,
         verbose,

package/dist/commands/screen-flow/index.d.ts

@@ -10,7 +10,9 @@
  */
 export interface ScreenFlowCliOptions {
     flowId: string;
+    /** Repo-only mode: generate against a single repositories row, no product. */
+    repoId?: string;
     guidance?: string;
     verbose?: boolean;
 }
-export declare function runScreenFlow(productId: string, options: ScreenFlowCliOptions): Promise<void>;
+export declare function runScreenFlow(productId: string | undefined, options: ScreenFlowCliOptions): Promise<void>;

package/dist/commands/screen-flow/index.js

@@ -12,18 +12,27 @@ import { runScreenFlowPhase } from '../../phases/screen-flow/index.js';
 import { deregisterSession, registerSession, } from '../../system/session-manager.js';
 import { logError, logInfo, logSuccess } from '../../utils/logger.js';
 export async function runScreenFlow(productId, options) {
-    const { flowId, guidance, verbose } = options;
-    if (!productId) {
-        throw new Error('Product ID is required for screen-flow');
+    const { flowId, repoId, guidance, verbose } = options;
+    if (!productId && !repoId) {
+        throw new Error('Either a product ID or --repo-id is required for screen-flow');
     }
     if (!flowId) {
         throw new Error('--flow-id is required (the pending flows row id)');
     }
-    await registerSession({ command: 'screen-flow', productId });
-    logInfo(`Starting screen flow generation for product ${productId}`);
+    await registerSession({
+        command: 'screen-flow',
+        ...(productId ? { productId } : {}),
+    });
+    if (productId) {
+        logInfo(`Starting screen flow generation for product ${productId}`);
+    }
+    else {
+        logInfo(`Starting screen flow generation for repository ${repoId}`);
+    }
     try {
         const result = await runScreenFlowPhase({
             productId,
+            repoId,
             flowId,
             guidance,
             verbose,

package/dist/commands/sync-org-repos/index.d.ts

@@ -1,8 +1,9 @@
 /**
  * CLI command: `edsger sync-org-repos <teamId>`
  *
- * Reads the team's configured github_org, fetches all repos from that org
- * via the local `gh` CLI, and upserts a repositories row for each repo.
+ * Reads the team's configured github_org and fetches all repos from that org
+ * server-side (via the Edsger GitHub App, falling back to the user's personal
+ * GitHub token), then upserts a repositories row for each repo.
  */
 export interface SyncOrgReposCliOptions {
     verbose?: boolean;

package/dist/commands/sync-org-repos/index.js

@@ -1,8 +1,9 @@
 /**
  * CLI command: `edsger sync-org-repos <teamId>`
  *
- * Reads the team's configured github_org, fetches all repos from that org
- * via the local `gh` CLI, and upserts a repositories row for each repo.
+ * Reads the team's configured github_org and fetches all repos from that org
+ * server-side (via the Edsger GitHub App, falling back to the user's personal
+ * GitHub token), then upserts a repositories row for each repo.
  */
 import { syncOrgRepos } from '../../phases/sync-org-repos/index.js';
 import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';

package/dist/index.js

@@ -172,15 +172,20 @@ program
 // Subcommand: edsger screen-flow <productId>
 // ============================================================
 program
-    .command('screen-flow <productId>')
-    .description('Generate a structured screen flow (screens + transitions) for a product from its source code')
+    .command('screen-flow [productId]')
+    .description('Generate a structured screen flow (screens + transitions) for a product (or standalone repository) from its source code')
     .requiredOption('--flow-id <id>', 'Pending flows row id to populate')
+    .option('--repo-id <id>', 'Run in repo-only mode against a single repositories row (no product context)')
     .option('-g, --guidance <text>', 'Human direction for the AI (focus areas, exclusions)')
     .option('-v, --verbose', 'Verbose output')
     .action(async (productId, opts) => {
     try {
+        if (!productId && !opts.repoId) {
+            throw new Error('Provide a productId or --repo-id (repo-only mode) for screen-flow');
+        }
         await runScreenFlow(productId, {
             flowId: opts.flowId,
+            repoId: opts.repoId,
             guidance: opts.guidance,
             verbose: opts.verbose,
         });
@@ -194,15 +199,20 @@ program
 // Subcommand: edsger data-flow <productId>
 // ============================================================
 program
-    .command('data-flow <productId>')
-    .description('Generate a structured data flow (sources, datasets, transforms, sinks, queues, models) for a product from its source code')
+    .command('data-flow [productId]')
+    .description('Generate a structured data flow (sources, datasets, transforms, sinks, queues, models) for a product (or standalone repository) from its source code')
     .requiredOption('--flow-id <id>', 'Pending flows row id to populate')
+    .option('--repo-id <id>', 'Run in repo-only mode against a single repositories row (no product context)')
     .option('-g, --guidance <text>', 'Human direction for the AI (focus areas, exclusions)')
     .option('-v, --verbose', 'Verbose output')
     .action(async (productId, opts) => {
     try {
+        if (!productId && !opts.repoId) {
+            throw new Error('Provide a productId or --repo-id (repo-only mode) for data-flow');
+        }
         await runDataFlow(productId, {
             flowId: opts.flowId,
+            repoId: opts.repoId,
             guidance: opts.guidance,
             verbose: opts.verbose,
         });
@@ -646,10 +656,10 @@ program
 // Subcommand: edsger quality-benchmark <productId>
 // ============================================================
 program
-    .command('quality-benchmark <productId>')
-    .description("Run an industrial-grade code quality benchmark against the product's GitHub repo")
+    .command('quality-benchmark [productId]')
+    .description("Run an industrial-grade code quality benchmark against the product's (or a standalone repository's) GitHub repo")
     .option('--repo <path>', "Override the auto-clone with a local checkout (default: clone the product's repo into ~/edsger/quality-<owner>-<repo>)")
-    .option('--repo-id <id>', "Benchmark a specific linked repository (id) instead of the product's primary repo")
+    .option('--repo-id <id>', "Benchmark a specific repository (id). With a productId, targets that linked repo; without a productId, runs in repo-only mode (no product)")
     .option('--branch <name>', 'Override the detected default branch on the report envelope')
     .option('--pkg-manager <name>', 'npm | pnpm | yarn (auto-detected if absent)')
     .option('--no-install', 'Refuse to install missing tools; mark them unmeasured')
@@ -659,7 +669,10 @@ program
     .option('-v, --verbose', 'Print every progress event')
     .action(async (productId, opts) => {
     try {
-        await runQualityBenchmarkCli(productId, opts);
+        if (!productId && !opts.repoId) {
+            throw new Error('Provide a productId or --repo-id (repo-only mode) for quality-benchmark');
+        }
+        await runQualityBenchmarkCli(productId ?? '', opts);
     }
     catch (error) {
         logError(error instanceof Error ? error.message : String(error));
@@ -687,7 +700,7 @@ program
 // ============================================================
 program
     .command('sync-org-repos <teamId>')
-    .description("Sync a GitHub org's repos as products under a team. Uses the local gh CLI.")
+    .description("Sync a GitHub org's repos under a team via the Edsger GitHub App, falling back to your personal GitHub token.")
     .option('-v, --verbose', 'Verbose output')
     .option('--org <name>', "GitHub org name (defaults to the team's configured github_org)")
     .action(async (teamId, opts) => {
@@ -888,15 +901,20 @@ program
 // Subcommand: edsger recipes <productId>
 // ============================================================
 program
-    .command('recipes <productId>')
-    .description("Scan a product's repo for the implementation recipes it uses (which services/tools are chained together to deliver each capability) and persist them via the recipes / product_recipes tables. Writes against the pending recipe_scans row identified by --scan-id.")
+    .command('recipes [productId]')
+    .description("Scan a product's (or standalone repository's) repo for the implementation recipes it uses (which services/tools are chained together to deliver each capability) and persist them via the recipes / product_recipes (or repository_recipes) tables. Writes against the pending recipe_scans row identified by --scan-id.")
     .requiredOption('--scan-id <id>', 'Pending recipe_scans row id to drive (created by the desktop UI before invocation)')
+    .option('--repo-id <id>', 'Run in repo-only mode against a single repositories row (no product context)')
     .option('-g, --guidance <text>', 'Human direction for the AI (focus areas, exclusions)')
     .option('-v, --verbose', 'Verbose output')
     .action(async (productId, opts) => {
     try {
+        if (!productId && !opts.repoId) {
+            throw new Error('Provide a productId or --repo-id (repo-only mode) for recipes');
+        }
         await runRecipes(productId, {
             scanId: opts.scanId,
+            repoId: opts.repoId,
             guidance: opts.guidance,
             verbose: opts.verbose,
         });

package/dist/phases/data-flow/index.d.ts

@@ -10,7 +10,10 @@
  * domain.
  */
 export interface DataFlowPhaseOptions {
-    productId: string;
+    /** Product-scoped flow. Mutually exclusive with `repoId`. */
+    productId?: string;
+    /** Repo-only flow: a single repositories row, no product context. */
+    repoId?: string;
     flowId: string;
     guidance?: string;
     verbose?: boolean;

package/dist/phases/data-flow/index.js

@@ -10,6 +10,7 @@
  * domain.
  */
 import { query } from '@anthropic-ai/claude-agent-sdk';
+import { getRepositoryBasics } from '../../api/github.js';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { getSupabase } from '../../supabase/client.js';
 import { logError, logInfo, logSuccess, logWarning } from '../../utils/logger.js';
@@ -27,13 +28,20 @@ const COLUMN_WIDTH = 320;
 const ROW_HEIGHT = 220;
 const COLUMNS = 4;
 export async function runDataFlowPhase(options) {
-    const { productId, flowId, guidance, verbose } = options;
-    logInfo(`Starting data-flow generation for product ${productId}`);
+    const { productId, repoId, flowId, guidance, verbose } = options;
+    const repoOnly = !productId && Boolean(repoId);
+    if (productId) {
+        logInfo(`Starting data-flow generation for product ${productId}`);
+    }
+    else {
+        logInfo(`Starting data-flow generation for repository ${repoId}`);
+    }
     const supabase = getSupabase();
     await markFlowRunning(supabase, flowId);
     const repositoryIds = await getFlowRepositoryIds(supabase, flowId);
     const cloneResult = await cloneFlowRepos({
         productId,
+        repoId,
         repositoryIds,
         workspaceKey: WORKSPACE_KEY,
         verbose,
@@ -45,7 +53,9 @@ export async function runDataFlowPhase(options) {
     const { projectDir, cleanupDir, repos } = cloneResult;
     let succeeded = false;
     try {
-        const product = await fetchProductBasics(productId);
+        const product = repoOnly
+            ? await resolveRepoBasics(repoId, repos)
+            : await fetchProductBasics(productId);
         const systemPrompt = await createDataFlowSystemPrompt({
             projectDir,
             hasCodebase: true,
@@ -118,6 +128,17 @@ export async function runDataFlowPhase(options) {
         }
     }
 }
+/**
+ * Build "product basics" for repo-only mode from the repositories row,
+ * falling back to the cloned repo's full name when the row has no name.
+ */
+async function resolveRepoBasics(repositoryId, repos) {
+    const basics = await getRepositoryBasics(repositoryId).catch(() => null);
+    return {
+        name: basics?.fullName ?? repos[0]?.fullName ?? repositoryId,
+        description: basics?.description ?? undefined,
+    };
+}
 /** Read the ordered repo set a flow was scoped to (may be empty). */
 async function getFlowRepositoryIds(supabase, flowId) {
     const { data } = await supabase

package/dist/phases/flow-shared/clone-repos.d.ts

@@ -35,8 +35,11 @@ export declare function safeDirName(fullName: string): string;
 /**
  * Resolve the repositories a flow targets (by id, preserving the stored
  * order), falling back to the product's primary repo.
+ *
+ * In repo-only mode there is no product, so no `fallback` is provided: the
+ * set is resolved purely from `repositoryIds`.
  */
-export declare function resolveTargetRepos(productId: string, repositoryIds: string[], fallback: {
+export declare function resolveTargetRepos(productId: string | undefined, repositoryIds: string[], fallback?: {
     owner: string;
     repo: string;
 }): Promise<{
@@ -45,7 +48,10 @@ export declare function resolveTargetRepos(productId: string, repositoryIds: str
     repo: string;
 }[]>;
 export declare function cloneFlowRepos(opts: {
-    productId: string;
+    /** Product-scoped flow. Mutually exclusive with `repoId`. */
+    productId?: string;
+    /** Repo-only flow: a single repositories row, no product context. */
+    repoId?: string;
     repositoryIds: string[];
     workspaceKey: string;
     verbose?: boolean;

package/dist/phases/flow-shared/clone-repos.js

@@ -13,7 +13,7 @@
  * Falls back to the product's primary repo when `repository_ids` is empty
  * (older flows, or single-repo products).
  */
-import { getGitHubConfigByProduct } from '../../api/github.js';
+import { getGitHubConfigByProduct, getGitHubConfigByRepository, } from '../../api/github.js';
 import { getSupabase } from '../../supabase/client.js';
 import { logInfo, logWarning } from '../../utils/logger.js';
 import { cloneIssueRepo, ensureWorkspaceDir, getIssueRepoPath, } from '../../workspace/workspace-manager.js';
@@ -23,16 +23,22 @@ export function safeDirName(fullName) {
 /**
  * Resolve the repositories a flow targets (by id, preserving the stored
  * order), falling back to the product's primary repo.
+ *
+ * In repo-only mode there is no product, so no `fallback` is provided: the
+ * set is resolved purely from `repositoryIds`.
  */
 export async function resolveTargetRepos(productId, repositoryIds, fallback) {
     if (repositoryIds.length === 0) {
-        return [
-            {
-                fullName: `${fallback.owner}/${fallback.repo}`,
-                owner: fallback.owner,
-                repo: fallback.repo,
-            },
-        ];
+        if (fallback) {
+            return [
+                {
+                    fullName: `${fallback.owner}/${fallback.repo}`,
+                    owner: fallback.owner,
+                    repo: fallback.repo,
+                },
+            ];
+        }
+        return [];
     }
     const supabase = getSupabase();
     const { data } = await supabase
@@ -54,8 +60,8 @@ export async function resolveTargetRepos(productId, repositoryIds, fallback) {
         resolved.push({ fullName, owner, repo });
     }
     // If none resolved (deleted repos / RLS), fall back to the primary repo so
-    // generation still produces something useful.
-    if (resolved.length === 0) {
+    // generation still produces something useful (product mode only).
+    if (resolved.length === 0 && fallback) {
         return [
             {
                 fullName: `${fallback.owner}/${fallback.repo}`,
@@ -67,21 +73,33 @@ export async function resolveTargetRepos(productId, repositoryIds, fallback) {
     return resolved;
 }
 export async function cloneFlowRepos(opts) {
-    const { productId, repositoryIds, workspaceKey, verbose } = opts;
-    const gh = await getGitHubConfigByProduct(productId, verbose);
+    const { productId, repoId, repositoryIds, workspaceKey, verbose } = opts;
+    const repoOnly = !productId && Boolean(repoId);
+    // Resolve the auth token. Product mode reuses the product's installation /
+    // PAT for every repo; repo-only mode resolves it from the first (only) repo.
+    const gh = repoOnly
+        ? await getGitHubConfigByRepository(repositoryIds[0] ?? repoId, verbose)
+        : await getGitHubConfigByProduct(productId, verbose);
     if (!gh.configured || !gh.token || !gh.owner || !gh.repo) {
         return {
             ok: false,
             message: gh.message ||
-                'GitHub repository not configured for this product. Connect a repo first.',
+                (repoOnly
+                    ? 'GitHub repository not configured. Connect the repo first.'
+                    : 'GitHub repository not configured for this product. Connect a repo first.'),
+        };
+    }
+    // In repo-only mode there is no product primary-repo fallback; targets come
+    // purely from repositoryIds.
+    const targets = await resolveTargetRepos(productId, repositoryIds, repoOnly ? undefined : { owner: gh.owner, repo: gh.repo });
+    if (targets.length === 0) {
+        return {
+            ok: false,
+            message: 'No repositories resolved for this flow.',
         };
     }
-    const targets = await resolveTargetRepos(productId, repositoryIds, {
-        owner: gh.owner,
-        repo: gh.repo,
-    });
     const workspaceRoot = ensureWorkspaceDir();
-    const parentDir = getIssueRepoPath(workspaceRoot, `${workspaceKey}-${productId}`);
+    const parentDir = getIssueRepoPath(workspaceRoot, `${workspaceKey}-${repoOnly ? `repo-${repoId}` : productId}`);
     const repos = [];
     for (const target of targets) {
         try {

package/dist/phases/recipes/index.d.ts

@@ -19,7 +19,10 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
 import type { RecipeSummary } from './types.js';
 export interface RecipesPhaseOptions {
-    productId: string;
+    /** Product-scoped scan. Mutually exclusive with `repoId`. */
+    productId?: string;
+    /** Repo-only scan: a single repositories row, no product context. */
+    repoId?: string;
     scanId: string;
     guidance?: string;
     verbose?: boolean;
@@ -44,6 +47,10 @@ export declare function listProductRecipeLinks(supabase: SupabaseClient, product
     recipe_id: string;
     name: string;
 }[]>;
+export declare function listRepositoryRecipeLinks(supabase: SupabaseClient, repositoryId: string): Promise<{
+    recipe_id: string;
+    name: string;
+}[]>;
 /**
  * Claim the row by flipping `pending` → `running`. Returns true on success
  * (we won the claim) and false when the row has already moved on (e.g. user

package/dist/phases/recipes/index.js

@@ -17,7 +17,7 @@
  *     progress survives even if the agent later errors out.
  */
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { getGitHubConfigByProduct } from '../../api/github.js';
+import { getGitHubConfigByProduct, getGitHubConfigByRepository, getRepositoryBasics, } from '../../api/github.js';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { getSupabase } from '../../supabase/client.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
@@ -33,8 +33,14 @@ const MAX_TURNS = 200;
 // flowing) lets the row go stale and the reader can mark it failed.
 const HEARTBEAT_MIN_INTERVAL_MS = 15_000;
 export async function runRecipesPhase(options) {
-    const { productId, scanId, guidance, verbose } = options;
-    logInfo(`Starting recipes scan for product ${productId}`);
+    const { productId, repoId, scanId, guidance, verbose } = options;
+    const repoOnly = !productId && Boolean(repoId);
+    if (productId) {
+        logInfo(`Starting recipes scan for product ${productId}`);
+    }
+    else {
+        logInfo(`Starting recipes scan for repository ${repoId}`);
+    }
     const supabase = getSupabase();
     const claimed = await markRunning(supabase, scanId);
     if (!claimed) {
@@ -43,19 +49,42 @@ export async function runRecipesPhase(options) {
             message: 'Recipe scan row is no longer in a runnable state (likely cancelled before the CLI started)',
         };
     }
-    const teamId = await getProductTeamId(supabase, productId);
-    if (!teamId) {
-        const msg = 'Product is not associated with a team; recipes are team-scoped and require one.';
-        await markFailed(supabase, scanId, msg);
-        return { status: 'error', message: msg };
+    // Resolve the team (recipes are team-scoped) + repo basics. In repo-only
+    // mode both come off the repositories row; in product mode from the product.
+    let teamId;
+    let repoBasics = {
+        fullName: null,
+        description: null,
+    };
+    if (repoOnly) {
+        const basics = await getRepositoryBasics(repoId);
+        teamId = basics.teamId;
+        repoBasics = { fullName: basics.fullName, description: basics.description };
+        if (!teamId) {
+            const msg = 'Repository is not associated with a team; recipes are team-scoped and require one.';
+            await markFailed(supabase, scanId, msg);
+            return { status: 'error', message: msg };
+        }
     }
-    const githubConfig = await getGitHubConfigByProduct(productId, verbose);
+    else {
+        teamId = await getProductTeamId(supabase, productId);
+        if (!teamId) {
+            const msg = 'Product is not associated with a team; recipes are team-scoped and require one.';
+            await markFailed(supabase, scanId, msg);
+            return { status: 'error', message: msg };
+        }
+    }
+    const githubConfig = repoOnly
+        ? await getGitHubConfigByRepository(repoId, verbose)
+        : await getGitHubConfigByProduct(productId, verbose);
     if (!githubConfig.configured ||
         !githubConfig.token ||
         !githubConfig.owner ||
         !githubConfig.repo) {
         const msg = githubConfig.message ||
-            'GitHub repository not configured for this product. Connect a repo first.';
+            (repoOnly
+                ? 'GitHub repository not configured. Connect the repo first.'
+                : 'GitHub repository not configured for this product. Connect a repo first.');
         await markFailed(supabase, scanId, msg);
         return { status: 'error', message: msg };
     }
@@ -63,13 +92,22 @@ export async function runRecipesPhase(options) {
     let succeeded = false;
     try {
         const workspaceRoot = ensureWorkspaceDir();
-        const repoKey = `${WORKSPACE_KEY}-${productId}`;
+        const repoKey = repoOnly
+            ? `${WORKSPACE_KEY}-repo-${repoId}`
+            : `${WORKSPACE_KEY}-${productId}`;
         ({ repoPath } = cloneIssueRepo(workspaceRoot, repoKey, githubConfig.owner, githubConfig.repo, githubConfig.token));
-        const [product, scanMeta, teamRecipes, existingLinks] = await Promise.all([
-            fetchProductBasics(productId),
+        const [basics, scanMeta, teamRecipes, existingLinks] = await Promise.all([
+            repoOnly
+                ? Promise.resolve({
+                    name: repoBasics.fullName ?? `${githubConfig.owner}/${githubConfig.repo}`,
+                    description: repoBasics.description ?? undefined,
+                })
+                : fetchProductBasics(productId),
             getScanCreator(supabase, scanId),
             listTeamRecipes(supabase, teamId),
-            listProductRecipeLinks(supabase, productId),
+            repoOnly
+                ? listRepositoryRecipeLinks(supabase, repoId)
+                : listProductRecipeLinks(supabase, productId),
         ]);
         if (!scanMeta) {
             const msg = 'recipe_scans row vanished mid-run; aborting';
@@ -78,8 +116,8 @@ export async function runRecipesPhase(options) {
         }
         const systemPrompt = createRecipesSystemPrompt();
         const userPrompt = createRecipesUserPrompt({
-            productName: product.name,
-            productDescription: product.description,
+            productName: basics.name,
+            productDescription: basics.description,
             guidance,
             teamRecipes,
             existingLinks: existingLinks.map((l) => ({
@@ -92,7 +130,8 @@ export async function runRecipesPhase(options) {
         const mcpServer = createRecipesMcpServer({
             supabase,
             teamId,
-            productId,
+            productId: repoOnly ? undefined : productId,
+            repositoryId: repoOnly ? repoId : undefined,
             createdBy: scanMeta.created_by,
         }, counts, teamRecipes, existingLinkIds);
         logInfo('Running Claude agent to identify recipes...');
@@ -229,6 +268,24 @@ export async function listProductRecipeLinks(supabase, productId) {
     }
     return out;
 }
+export async function listRepositoryRecipeLinks(supabase, repositoryId) {
+    const { data, error } = await supabase
+        .from('repository_recipes')
+        .select('recipe_id, recipes(name)')
+        .eq('repository_id', repositoryId);
+    if (error || !data) {
+        return [];
+    }
+    const rows = data;
+    const out = [];
+    for (const r of rows) {
+        const recipe = Array.isArray(r.recipes) ? r.recipes[0] : r.recipes;
+        if (recipe) {
+            out.push({ recipe_id: r.recipe_id, name: recipe.name });
+        }
+    }
+    return out;
+}
 /**
  * Claim the row by flipping `pending` → `running`. Returns true on success
  * (we won the claim) and false when the row has already moved on (e.g. user

package/dist/phases/recipes/mcp-server.d.ts

@@ -22,7 +22,10 @@ import { type RecipeSummary } from './types.js';
 export interface RecipesToolContext {
     supabase: SupabaseClient;
     teamId: string;
-    productId: string;
+    /** Set in product-scoped scans; links go to `product_recipes`. */
+    productId?: string;
+    /** Set in repo-only scans; links go to `repository_recipes`. */
+    repositoryId?: string;
     createdBy: string;
 }
 /**

package/dist/phases/recipes/mcp-server.js

@@ -19,6 +19,27 @@
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
 import { z } from 'zod';
 import { RECIPE_CONTENT_MAX, RECIPE_EVIDENCE_MAX, RECIPE_NAME_MAX, RECIPE_SERVICE_NAME_MAX, RECIPE_SERVICES_MAX, RECIPE_SUMMARY_MAX, } from './types.js';
+function resolveLinkScope(ctx) {
+    if (ctx.repositoryId) {
+        return {
+            table: 'repository_recipes',
+            column: 'repository_id',
+            id: ctx.repositoryId,
+            onConflict: 'repository_id,recipe_id',
+            label: 'this repository',
+        };
+    }
+    if (ctx.productId) {
+        return {
+            table: 'product_recipes',
+            column: 'product_id',
+            id: ctx.productId,
+            onConflict: 'product_id,recipe_id',
+            label: 'this product',
+        };
+    }
+    throw new Error('RecipesToolContext requires either productId or repositoryId to scope links');
+}
 export function createRecipesMutationCounts() {
     return { created: 0, updated: 0, linked: 0, unlinked: 0 };
 }
@@ -92,17 +113,18 @@ export function createCreateRecipeTool(ctx, counts, teamRecipeIds) {
             return textError(`Failed to create recipe: ${insertRecipe.error?.message ?? 'unknown error'}`);
         }
         const recipeId = insertRecipe.data.id;
-        const linkErr = await ctx.supabase.from('product_recipes').insert({
-            product_id: ctx.productId,
+        const scope = resolveLinkScope(ctx);
+        const linkErr = await ctx.supabase.from(scope.table).insert({
+            [scope.column]: scope.id,
             recipe_id: recipeId,
             evidence: args.evidence.trim(),
         });
         if (linkErr.error) {
-            return textError(`Recipe created (${recipeId}) but linking to product failed: ${linkErr.error.message}`);
+            return textError(`Recipe created (${recipeId}) but linking to ${scope.label} failed: ${linkErr.error.message}`);
         }
         teamRecipeIds.add(recipeId);
         counts.created += 1;
-        return textOk(`Created recipe ${recipeId} and linked to this product.`);
+        return textOk(`Created recipe ${recipeId} and linked to ${scope.label}.`);
     });
 }
 export function createUpdateRecipeTool(ctx, counts, teamRecipeIds) {
@@ -136,16 +158,17 @@ export function createUpdateRecipeTool(ctx, counts, teamRecipeIds) {
                 return textError(`Failed to update recipe: ${updateErr.error.message}`);
             }
         }
-        const linkErr = await ctx.supabase.from('product_recipes').upsert({
-            product_id: ctx.productId,
+        const scope = resolveLinkScope(ctx);
+        const linkErr = await ctx.supabase.from(scope.table).upsert({
+            [scope.column]: scope.id,
             recipe_id: args.recipe_id,
             evidence: args.evidence.trim(),
-        }, { onConflict: 'product_id,recipe_id' });
+        }, { onConflict: scope.onConflict });
         if (linkErr.error) {
-            return textError(`Recipe updated but linking to product failed: ${linkErr.error.message}`);
+            return textError(`Recipe updated but linking to ${scope.label} failed: ${linkErr.error.message}`);
         }
         counts.updated += 1;
-        return textOk(`Updated recipe ${args.recipe_id} and linked to this product.`);
+        return textOk(`Updated recipe ${args.recipe_id} and linked to ${scope.label}.`);
     });
 }
 export function createLinkRecipeTool(ctx, counts, teamRecipeIds) {
@@ -156,36 +179,38 @@ export function createLinkRecipeTool(ctx, counts, teamRecipeIds) {
         if (!teamRecipeIds.has(args.recipe_id)) {
             return textError(`recipe_id ${args.recipe_id} is not in this team's recipe list. Use create_recipe for new entries.`);
         }
-        const linkErr = await ctx.supabase.from('product_recipes').upsert({
-            product_id: ctx.productId,
+        const scope = resolveLinkScope(ctx);
+        const linkErr = await ctx.supabase.from(scope.table).upsert({
+            [scope.column]: scope.id,
             recipe_id: args.recipe_id,
             evidence: args.evidence.trim(),
-        }, { onConflict: 'product_id,recipe_id' });
+        }, { onConflict: scope.onConflict });
         if (linkErr.error) {
             return textError(`Failed to link recipe: ${linkErr.error.message}`);
         }
         counts.linked += 1;
-        return textOk(`Linked recipe ${args.recipe_id} to this product.`);
+        return textOk(`Linked recipe ${args.recipe_id} to ${scope.label}.`);
     });
 }
 export function createUnlinkRecipeTool(ctx, counts, existingLinkIds) {
-    return tool('unlink_recipe', 'Drop a previously-linked recipe that you have confirmed is NO LONGER present in this repo. Only call this for ids in the "Currently linked to this product" list. Does not delete the recipe itself.', {
+    return tool('unlink_recipe', 'Drop a previously-linked recipe that you have confirmed is NO LONGER present in this repo. Only call this for ids in the "Currently linked" list. Does not delete the recipe itself.', {
         recipe_id: z.string().uuid(),
     }, async (args) => {
         if (!existingLinkIds.has(args.recipe_id)) {
-            return textError(`recipe_id ${args.recipe_id} is not in the "Currently linked to this product" list — nothing to unlink.`);
+            return textError(`recipe_id ${args.recipe_id} is not in the "Currently linked" list — nothing to unlink.`);
         }
+        const scope = resolveLinkScope(ctx);
         const { error } = await ctx.supabase
-            .from('product_recipes')
+            .from(scope.table)
             .delete()
-            .eq('product_id', ctx.productId)
+            .eq(scope.column, scope.id)
             .eq('recipe_id', args.recipe_id);
         if (error) {
             return textError(`Failed to unlink recipe: ${error.message}`);
         }
         existingLinkIds.delete(args.recipe_id);
         counts.unlinked += 1;
-        return textOk(`Unlinked recipe ${args.recipe_id} from this product.`);
+        return textOk(`Unlinked recipe ${args.recipe_id} from ${scope.label}.`);
     });
 }
 export function createRecipesMcpServer(ctx, counts, teamRecipes, existingLinkIds) {

package/dist/phases/screen-flow/index.d.ts

@@ -8,7 +8,10 @@
  * pattern, but writes to its own tables rather than filing issues.
  */
 export interface ScreenFlowOptions {
-    productId: string;
+    /** Product-scoped flow. Mutually exclusive with `repoId`. */
+    productId?: string;
+    /** Repo-only flow: a single repositories row, no product context. */
+    repoId?: string;
     flowId: string;
     guidance?: string;
     verbose?: boolean;

package/dist/phases/screen-flow/index.js

@@ -8,6 +8,7 @@
  * pattern, but writes to its own tables rather than filing issues.
  */
 import { query } from '@anthropic-ai/claude-agent-sdk';
+import { getRepositoryBasics } from '../../api/github.js';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { getSupabase } from '../../supabase/client.js';
 import { logError, logInfo, logSuccess, logWarning } from '../../utils/logger.js';
@@ -26,13 +27,20 @@ const COLUMN_WIDTH = 380;
 const ROW_HEIGHT = 480;
 const COLUMNS = 4;
 export async function runScreenFlowPhase(options) {
-    const { productId, flowId, guidance, verbose } = options;
-    logInfo(`Starting screen-flow generation for product ${productId}`);
+    const { productId, repoId, flowId, guidance, verbose } = options;
+    const repoOnly = !productId && Boolean(repoId);
+    if (productId) {
+        logInfo(`Starting screen-flow generation for product ${productId}`);
+    }
+    else {
+        logInfo(`Starting screen-flow generation for repository ${repoId}`);
+    }
     const supabase = getSupabase();
     await markFlowRunning(supabase, flowId);
     const repositoryIds = await getFlowRepositoryIds(supabase, flowId);
     const cloneResult = await cloneFlowRepos({
         productId,
+        repoId,
         repositoryIds,
         workspaceKey: WORKSPACE_KEY,
         verbose,
@@ -44,7 +52,9 @@ export async function runScreenFlowPhase(options) {
     const { projectDir, cleanupDir, repos } = cloneResult;
     let succeeded = false;
     try {
-        const product = await fetchProductBasics(productId);
+        const product = repoOnly
+            ? await resolveRepoBasics(repoId, repos)
+            : await fetchProductBasics(productId);
         const systemPrompt = await createScreenFlowSystemPrompt({
             projectDir,
             hasCodebase: true,
@@ -148,6 +158,17 @@ function resolveTheme(agentTheme, repos) {
     }
     return {};
 }
+/**
+ * Build "product basics" for repo-only mode from the repositories row,
+ * falling back to the cloned repo's full name when the row has no name.
+ */
+async function resolveRepoBasics(repositoryId, repos) {
+    const basics = await getRepositoryBasics(repositoryId).catch(() => null);
+    return {
+        name: basics?.fullName ?? repos[0]?.fullName ?? repositoryId,
+        description: basics?.description ?? undefined,
+    };
+}
 /** Read the ordered repo set a flow was scoped to (may be empty). */
 async function getFlowRepositoryIds(supabase, flowId) {
     const { data } = await supabase

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.67.0",
+  "version": "0.69.0",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"