edsger 0.56.3 → 0.57.0

package/dist/phases/product-test-cases/types.js

@@ -0,0 +1,27 @@
+/**
+ * Wire shape for the product-test-cases agent output. The agent is asked to
+ * emit `{ test_cases_result: { ... } }`; we validate it loosely so a single
+ * stray field doesn't kill an otherwise-good run.
+ */
+export function isProductTestCasesAgentResult(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const v = value;
+    if (typeof v.summary !== 'string') {
+        return false;
+    }
+    if (!Array.isArray(v.created_test_cases)) {
+        return false;
+    }
+    for (const tc of v.created_test_cases) {
+        if (!tc || typeof tc !== 'object') {
+            return false;
+        }
+        const t = tc;
+        if (typeof t.name !== 'string' || typeof t.description !== 'string') {
+            return false;
+        }
+    }
+    return true;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * screen-flow phase: clone the product's repo, ask Claude to map every
+ * user-facing screen and the transitions between them into a structured
+ * ScreenFlowExtraction, then persist the result to screen_flows /
+ * screen_flow_nodes / screen_flow_edges via the Supabase SDK.
+ *
+ * Companion to find-architecture / find-bugs / find-features. Same workspace
+ * pattern, but writes to its own tables rather than filing issues.
+ */
+export interface ScreenFlowOptions {
+    productId: string;
+    flowId: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export interface ScreenFlowResult {
+    status: 'success' | 'error';
+    message: string;
+    nodesCreated?: number;
+    edgesCreated?: number;
+    summary?: string;
+}
+export declare function runScreenFlowPhase(options: ScreenFlowOptions): Promise<ScreenFlowResult>;

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

@@ -0,0 +1,229 @@
+/**
+ * screen-flow phase: clone the product's repo, ask Claude to map every
+ * user-facing screen and the transitions between them into a structured
+ * ScreenFlowExtraction, then persist the result to screen_flows /
+ * screen_flow_nodes / screen_flow_edges via the Supabase SDK.
+ *
+ * Companion to find-architecture / find-bugs / find-features. Same workspace
+ * pattern, but writes to its own tables rather than filing issues.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { getGitHubConfigByProduct } 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';
+import { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
+import { fetchProductBasics } from '../find-shared/mcp.js';
+import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
+import { createScreenFlowSystemPrompt, createScreenFlowUserPrompt, } from './prompts.js';
+import { extractTheme } from './theme.js';
+import { isScreenFlowExtraction, } from './types.js';
+const WORKSPACE_KEY = 'screen-flow';
+const MAX_TURNS = 150;
+// Auto-layout: simple grid; users can drag afterwards and we persist positions.
+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 supabase = getSupabase();
+    await markFlowRunning(supabase, flowId);
+    const githubConfig = 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.';
+        await markFlowFailed(supabase, flowId, msg);
+        return { status: 'error', message: msg };
+    }
+    let repoPath;
+    let succeeded = false;
+    try {
+        const workspaceRoot = ensureWorkspaceDir();
+        const repoKey = `${WORKSPACE_KEY}-${productId}`;
+        ({ repoPath } = cloneIssueRepo(workspaceRoot, repoKey, githubConfig.owner, githubConfig.repo, githubConfig.token));
+        const product = await fetchProductBasics(productId);
+        const theme = extractTheme(repoPath);
+        if (Object.keys(theme).length > 0) {
+            logInfo(`Extracted theme: ${Object.entries(theme).map(([k, v]) => `${k}=${v}`).join(', ')}`);
+            await persistTheme(supabase, flowId, theme);
+        }
+        const systemPrompt = await createScreenFlowSystemPrompt({
+            projectDir: repoPath,
+            hasCodebase: true,
+        });
+        const userPrompt = createScreenFlowUserPrompt({
+            productName: product.name,
+            productDescription: product.description,
+            guidance,
+        });
+        logInfo('Running Claude screen-flow extraction...');
+        let lastAssistantResponse = '';
+        let extraction = null;
+        for await (const message of query({
+            prompt: createPromptGenerator(userPrompt),
+            options: {
+                systemPrompt: {
+                    type: 'preset',
+                    preset: 'claude_code',
+                    append: systemPrompt,
+                },
+                model: DEFAULT_MODEL,
+                maxTurns: MAX_TURNS,
+                permissionMode: 'bypassPermissions',
+                cwd: repoPath,
+            },
+        })) {
+            if (message.type === 'assistant') {
+                lastAssistantResponse += extractTextFromContent(message.message?.content ?? [], verbose);
+                continue;
+            }
+            if (message.type !== 'result') {
+                continue;
+            }
+            const responseText = message.subtype === 'success'
+                ? message.result || lastAssistantResponse
+                : lastAssistantResponse;
+            const parsed = tryExtractResult(responseText, 'screen_flow');
+            if (isScreenFlowExtraction(parsed)) {
+                extraction = parsed;
+            }
+            else if (message.subtype !== 'success') {
+                logError(`Extraction incomplete: ${message.subtype}`);
+            }
+        }
+        if (!extraction) {
+            const msg = 'Screen flow extraction failed: could not parse a screen_flow result from the agent';
+            await markFlowFailed(supabase, flowId, msg);
+            return { status: 'error', message: msg };
+        }
+        logInfo(`Extraction produced ${extraction.nodes.length} screens / ${extraction.edges.length} transitions`);
+        const { nodesCreated, edgesCreated } = await persistFlow(supabase, flowId, extraction);
+        await markFlowSuccess(supabase, flowId, extraction.summary);
+        succeeded = true;
+        logSuccess(`Screen flow generated: ${nodesCreated} screens, ${edgesCreated} transitions`);
+        return {
+            status: 'success',
+            message: `Screen flow generated (${nodesCreated} screens, ${edgesCreated} transitions)`,
+            nodesCreated,
+            edgesCreated,
+            summary: extraction.summary,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Screen flow failed: ${errorMessage}`);
+        await markFlowFailed(supabase, flowId, errorMessage);
+        return { status: 'error', message: errorMessage };
+    }
+    finally {
+        if (succeeded) {
+            cleanupIssueRepo(repoPath);
+        }
+    }
+}
+// ============================================================================
+// Persistence
+// ============================================================================
+async function markFlowRunning(supabase, flowId) {
+    const { error } = await supabase
+        .from('screen_flows')
+        .update({ status: 'running', error: null })
+        .eq('id', flowId);
+    if (error) {
+        logWarning(`Could not mark flow as running: ${error.message}`);
+    }
+}
+async function markFlowFailed(supabase, flowId, errorMessage) {
+    await supabase
+        .from('screen_flows')
+        .update({
+        status: 'failed',
+        error: errorMessage,
+        completed_at: new Date().toISOString(),
+    })
+        .eq('id', flowId);
+}
+async function persistTheme(supabase, flowId, theme) {
+    const { error } = await supabase
+        .from('screen_flows')
+        .update({ theme })
+        .eq('id', flowId);
+    if (error) {
+        logWarning(`Could not persist extracted theme: ${error.message}`);
+    }
+}
+async function markFlowSuccess(supabase, flowId, summary) {
+    await supabase
+        .from('screen_flows')
+        .update({
+        status: 'success',
+        summary,
+        error: null,
+        completed_at: new Date().toISOString(),
+    })
+        .eq('id', flowId);
+}
+async function persistFlow(supabase, flowId, extraction) {
+    // Re-runs replace prior content for the same flow row.
+    await supabase.from('screen_flow_edges').delete().eq('flow_id', flowId);
+    await supabase.from('screen_flow_nodes').delete().eq('flow_id', flowId);
+    if (extraction.nodes.length === 0) {
+        return { nodesCreated: 0, edgesCreated: 0 };
+    }
+    const nodeRows = extraction.nodes.map((n, i) => buildNodeRow(flowId, n, i));
+    const { data: insertedNodes, error: nodesError } = await supabase
+        .from('screen_flow_nodes')
+        .insert(nodeRows)
+        .select('id, slug');
+    if (nodesError) {
+        throw new Error(`Failed to insert nodes: ${nodesError.message}`);
+    }
+    const slugToId = new Map((insertedNodes ?? []).map((n) => [n.slug, n.id]));
+    const edgeRows = extraction.edges
+        .map((e) => buildEdgeRow(flowId, e, slugToId))
+        .filter((e) => e !== null);
+    if (edgeRows.length > 0) {
+        const { error: edgesError } = await supabase
+            .from('screen_flow_edges')
+            .insert(edgeRows);
+        if (edgesError) {
+            throw new Error(`Failed to insert edges: ${edgesError.message}`);
+        }
+    }
+    return {
+        nodesCreated: insertedNodes?.length ?? 0,
+        edgesCreated: edgeRows.length,
+    };
+}
+function buildNodeRow(flowId, node, index) {
+    return {
+        flow_id: flowId,
+        slug: node.slug,
+        name: node.name,
+        route: node.route ?? null,
+        file: node.file ?? null,
+        kind: node.kind,
+        schema: node,
+        position_x: (index % COLUMNS) * COLUMN_WIDTH,
+        position_y: Math.floor(index / COLUMNS) * ROW_HEIGHT,
+    };
+}
+function buildEdgeRow(flowId, edge, slugToId) {
+    const fromId = slugToId.get(edge.fromSlug);
+    const toId = slugToId.get(edge.toSlug);
+    if (!fromId || !toId) {
+        return null;
+    }
+    return {
+        flow_id: flowId,
+        from_node_id: fromId,
+        to_node_id: toId,
+        trigger_label: edge.triggerLabel,
+        trigger_file: edge.triggerFile ?? null,
+        kind: edge.kind,
+    };
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Prompts for the screen-flow phase.
+ *
+ * The system prompt body lives in the edsger-skills package
+ * (`skills/phase/screen-flow/SKILL.md`) so it can be project-overridden via
+ * `.claude/skills/edsger/phase/screen-flow/SKILL.md`, edited as plain MD
+ * without TS recompilation, and shared with the Claude Code plugin chain.
+ * The JSON output contract is appended from `output-contracts.ts` and is NOT
+ * user-overridable — the persistence layer relies on its exact shape.
+ */
+export declare function createScreenFlowSystemPrompt(options?: {
+    projectDir?: string;
+    hasCodebase?: boolean;
+}): Promise<string>;
+export declare function createScreenFlowUserPrompt(args: {
+    productName: string;
+    productDescription?: string;
+    guidance?: string;
+}): string;

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

@@ -0,0 +1,39 @@
+/**
+ * Prompts for the screen-flow phase.
+ *
+ * The system prompt body lives in the edsger-skills package
+ * (`skills/phase/screen-flow/SKILL.md`) so it can be project-overridden via
+ * `.claude/skills/edsger/phase/screen-flow/SKILL.md`, edited as plain MD
+ * without TS recompilation, and shared with the Claude Code plugin chain.
+ * The JSON output contract is appended from `output-contracts.ts` and is NOT
+ * user-overridable — the persistence layer relies on its exact shape.
+ */
+import { processConditionals, resolveSkill, } from '../../services/skill-resolver.js';
+import { OUTPUT_CONTRACTS } from '../output-contracts.js';
+export async function createScreenFlowSystemPrompt(options) {
+    const skill = await resolveSkill('phase/screen-flow', {
+        projectDir: options?.projectDir,
+    });
+    if (!skill) {
+        throw new Error('Failed to load skill: phase/screen-flow');
+    }
+    const prompt = processConditionals(skill.prompt, {
+        hasCodebase: options?.hasCodebase ?? true,
+    });
+    return `${prompt}
+
+${OUTPUT_CONTRACTS['screen-flow']}`;
+}
+export function createScreenFlowUserPrompt(args) {
+    const guidanceBlock = args.guidance
+        ? `\n\n**Human guidance for this run** (focus or exclude as instructed):\n${args.guidance}`
+        : '';
+    const descBlock = args.productDescription
+        ? `\n**Product description**: ${args.productDescription}`
+        : '';
+    return `Map the user-facing screen flow for **${args.productName}**.${descBlock}${guidanceBlock}
+
+Start by detecting the framework (check package.json / pubspec.yaml / Package.swift), then locate the router definition or pages directory. Read just enough source per screen to fill in a useful ScreenSchema — do not need to read everything.
+
+When done, emit the single \`screen_flow\` JSON block.`;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Theme extraction for screen-flow renders.
+ *
+ * The repo is already cloned on disk when this runs; we do best-effort
+ * static parsing of Tailwind config (and a couple of common alternatives)
+ * to pull out a primary color, a neutral color, a radius, and a font.
+ * Misses are fine — the renderer falls back to its own defaults.
+ *
+ * Intentionally simple: regex over the source text. We're not building an
+ * AST evaluator. If the user has anything exotic, they can edit the theme
+ * later from the desktop UI.
+ */
+export interface ScreenFlowTheme {
+    primary?: string;
+    neutral?: string;
+    radius?: string;
+    font?: string;
+}
+export declare function extractTheme(repoPath: string): ScreenFlowTheme;

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

@@ -0,0 +1,182 @@
+/**
+ * Theme extraction for screen-flow renders.
+ *
+ * The repo is already cloned on disk when this runs; we do best-effort
+ * static parsing of Tailwind config (and a couple of common alternatives)
+ * to pull out a primary color, a neutral color, a radius, and a font.
+ * Misses are fine — the renderer falls back to its own defaults.
+ *
+ * Intentionally simple: regex over the source text. We're not building an
+ * AST evaluator. If the user has anything exotic, they can edit the theme
+ * later from the desktop UI.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+const TAILWIND_CONFIG_CANDIDATES = [
+    'tailwind.config.ts',
+    'tailwind.config.js',
+    'tailwind.config.cjs',
+    'tailwind.config.mjs',
+];
+// Common alternatives a project might use for a "tokens" file.
+const TOKENS_CANDIDATES = [
+    'src/theme.json',
+    'theme.json',
+    'src/design-tokens.json',
+];
+const HEX_RE = /#[0-9a-fA-F]{3,8}\b/g;
+const RGB_RE = /rgba?\([^)]+\)/g;
+const HSL_RE = /hsla?\([^)]+\)/g;
+const OKLCH_RE = /oklch\([^)]+\)/g;
+export function extractTheme(repoPath) {
+    const theme = {};
+    // Tailwind config — pull primary/neutral colors out of the colors block
+    for (const candidate of TAILWIND_CONFIG_CANDIDATES) {
+        const fullPath = join(repoPath, candidate);
+        if (!existsSync(fullPath)) {
+            continue;
+        }
+        try {
+            const source = readFileSync(fullPath, 'utf-8');
+            const fromTw = parseTailwindColors(source);
+            Object.assign(theme, stripUndefined(fromTw));
+            break;
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    // Common project-side tokens
+    for (const candidate of TOKENS_CANDIDATES) {
+        const fullPath = join(repoPath, candidate);
+        if (!existsSync(fullPath)) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(readFileSync(fullPath, 'utf-8'));
+            const fromTokens = parseTokensJson(parsed);
+            Object.assign(theme, stripUndefined(fromTokens));
+        }
+        catch {
+            // Skip
+        }
+    }
+    // CSS variables in a global stylesheet — last-ditch fallback
+    const globalCssCandidates = [
+        'src/index.css',
+        'src/styles/globals.css',
+        'src/app/globals.css',
+        'app/globals.css',
+        'styles/globals.css',
+    ];
+    if (!theme.primary || !theme.radius || !theme.font) {
+        for (const candidate of globalCssCandidates) {
+            const fullPath = join(repoPath, candidate);
+            if (!existsSync(fullPath)) {
+                continue;
+            }
+            try {
+                const source = readFileSync(fullPath, 'utf-8');
+                const fromCss = parseGlobalCss(source);
+                Object.assign(theme, stripUndefined({ ...fromCss, ...theme }));
+                break;
+            }
+            catch {
+                // Skip
+            }
+        }
+    }
+    return theme;
+}
+function parseTailwindColors(source) {
+    const theme = {};
+    // Look for `primary:` and `neutral:` keys in any nested object. Accept
+    // either a single string ("primary: '#ff0066'") or an object containing
+    // a 500 key (the Tailwind convention).
+    const primaryString = matchColorEntry(source, 'primary');
+    if (primaryString)
+        theme.primary = primaryString;
+    const neutralString = matchColorEntry(source, 'neutral');
+    if (neutralString)
+        theme.neutral = neutralString;
+    // Pull a radius default if defined under theme.borderRadius
+    const radiusMatch = source.match(/borderRadius\s*:\s*{[^}]*?(?:DEFAULT|md|lg)\s*:\s*['"]([^'"]+)['"]/);
+    if (radiusMatch)
+        theme.radius = radiusMatch[1];
+    // Pull the default sans font family
+    const fontMatch = source.match(/fontFamily\s*:\s*{[^}]*?sans\s*:\s*\[?\s*['"]([^'"]+)['"]/);
+    if (fontMatch)
+        theme.font = fontMatch[1];
+    return theme;
+}
+function matchColorEntry(source, key) {
+    // Match `<key>: '#abc'` or `<key>: "rgb(…)" / hsl(…) / oklch(…)`
+    const stringRe = new RegExp(`${key}\\s*:\\s*['\"\`](#[0-9a-fA-F]{3,8}|rgba?\\([^)]+\\)|hsla?\\([^)]+\\)|oklch\\([^)]+\\))['\"\`]`);
+    const strMatch = source.match(stringRe);
+    if (strMatch) {
+        return strMatch[1];
+    }
+    // Match nested `<key>: { ... 500: '#abc' ... }`
+    const nestedRe = new RegExp(`${key}\\s*:\\s*\\{[^}]*?500\\s*:\\s*['\"\`]([^'\"\`]+)['\"\`]`);
+    const nested = source.match(nestedRe);
+    if (nested) {
+        const value = nested[1];
+        if (isColorish(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function parseTokensJson(json) {
+    const theme = {};
+    const colors = (json.colors ?? json.color);
+    if (colors && typeof colors === 'object') {
+        const primary = colors.primary;
+        if (typeof primary === 'string')
+            theme.primary = primary;
+        else if (primary && typeof primary === 'object' && '500' in primary) {
+            theme.primary = primary['500'];
+        }
+        const neutral = colors.neutral;
+        if (typeof neutral === 'string')
+            theme.neutral = neutral;
+        else if (neutral && typeof neutral === 'object' && '500' in neutral) {
+            theme.neutral = neutral['500'];
+        }
+    }
+    if (typeof json.radius === 'string')
+        theme.radius = json.radius;
+    if (typeof json.font === 'string')
+        theme.font = json.font;
+    return theme;
+}
+function parseGlobalCss(source) {
+    const theme = {};
+    const primaryMatch = source.match(/--primary\s*:\s*([^;]+);/);
+    if (primaryMatch) {
+        const value = primaryMatch[1].trim();
+        if (isColorish(value))
+            theme.primary = value;
+        else
+            theme.primary = `hsl(${value})`; // common shadcn pattern
+    }
+    const radiusMatch = source.match(/--radius\s*:\s*([^;]+);/);
+    if (radiusMatch)
+        theme.radius = radiusMatch[1].trim();
+    return theme;
+}
+function isColorish(value) {
+    return (HEX_RE.test(value) ||
+        RGB_RE.test(value) ||
+        HSL_RE.test(value) ||
+        OKLCH_RE.test(value));
+}
+function stripUndefined(obj) {
+    const out = {};
+    for (const k of Object.keys(obj)) {
+        if (obj[k] !== undefined && obj[k] !== '') {
+            out[k] = obj[k];
+        }
+    }
+    return out;
+}

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

@@ -0,0 +1,130 @@
+/**
+ * Screen Flow domain types.
+ *
+ * A ScreenSchema is a structured, framework-agnostic description of one
+ * screen in a product. The CLI extracts these from source code and the
+ * desktop renders them with a unified <ScreenPreview> component — that's
+ * what gives every flow a consistent visual style regardless of the
+ * underlying app's design system.
+ *
+ * The schema deliberately stays high-level (sections, not pixels). When the
+ * agent encounters something it can't model cleanly, it falls back to
+ * `{ type: 'custom', label }` rather than guessing.
+ */
+export type ScreenKind = 'page' | 'modal' | 'drawer' | 'tab' | 'state';
+export type ScreenLayout = 'centered' | 'sidebar' | 'split' | 'list-detail' | 'tabs' | 'stacked';
+export interface ScreenAction {
+    label: string;
+    variant?: 'primary' | 'secondary' | 'ghost' | 'destructive';
+    icon?: string;
+}
+export interface ScreenHeader {
+    title: string;
+    subtitle?: string;
+    back?: boolean;
+    actions?: ScreenAction[];
+}
+export interface FormField {
+    label: string;
+    kind: 'text' | 'email' | 'password' | 'textarea' | 'select' | 'checkbox' | 'date' | 'number';
+    placeholder?: string;
+    value?: string;
+    required?: boolean;
+}
+export interface ListItem {
+    title: string;
+    subtitle?: string;
+    meta?: string;
+    icon?: string;
+}
+export interface CardItem {
+    title: string;
+    subtitle?: string;
+    meta?: string;
+}
+export interface KanbanColumn {
+    title: string;
+    cards: {
+        title: string;
+        meta?: string;
+    }[];
+}
+export type ScreenSection = {
+    type: 'form';
+    fields: FormField[];
+    submitLabel: string;
+    secondaryLabel?: string;
+} | {
+    type: 'list';
+    items: ListItem[];
+    emptyMessage?: string;
+} | {
+    type: 'card-grid';
+    cards: CardItem[];
+    columns?: 2 | 3 | 4;
+} | {
+    type: 'table';
+    columns: string[];
+    rows: string[][];
+} | {
+    type: 'kanban';
+    columns: KanbanColumn[];
+} | {
+    type: 'text';
+    content: string;
+} | {
+    type: 'image';
+    alt: string;
+    aspect?: 'video' | 'square' | 'wide';
+} | {
+    type: 'chart';
+    chartKind: 'line' | 'bar' | 'pie';
+    label?: string;
+} | {
+    type: 'stats';
+    items: {
+        label: string;
+        value: string;
+        delta?: string;
+    }[];
+} | {
+    type: 'empty-state';
+    title: string;
+    message?: string;
+    cta?: string;
+} | {
+    type: 'tabs';
+    tabs: string[];
+    activeIndex?: number;
+} | {
+    type: 'custom';
+    label: string;
+};
+export interface ScreenSchema {
+    /** Stable slug within the flow (e.g. 'login', 'product-detail') */
+    slug: string;
+    /** Human-readable name */
+    name: string;
+    /** URL path or navigator key; null/undefined for modals */
+    route?: string;
+    /** Source file path (jump anchor) */
+    file?: string;
+    kind: ScreenKind;
+    layout: ScreenLayout;
+    header?: ScreenHeader;
+    body: ScreenSection[];
+}
+export type ScreenEdgeKind = 'navigate' | 'modal' | 'redirect' | 'back';
+export interface ScreenEdge {
+    fromSlug: string;
+    toSlug: string;
+    triggerLabel: string;
+    triggerFile?: string;
+    kind: ScreenEdgeKind;
+}
+export interface ScreenFlowExtraction {
+    summary: string;
+    nodes: ScreenSchema[];
+    edges: ScreenEdge[];
+}
+export declare function isScreenFlowExtraction(value: unknown): value is ScreenFlowExtraction;