edsger 0.76.0 → 0.78.0

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

@@ -1,286 +0,0 @@
-/**
- * data-flow phase: clone the product's repo, ask Claude to map every data
- * node (source / dataset / transform / sink / queue / model) and the
- * connections between them into a structured DataFlowExtraction, then
- * persist the result to diagrams / diagram_nodes / diagram_edges (rows tagged
- * `type = 'data'`) via the Supabase SDK.
- *
- * Companion to screen-flow: same generation pattern (workspace clone +
- * Claude Agent SDK + in-process MCP server), same storage tables, different
- * 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';
-import { cleanupIssueRepo } from '../../workspace/workspace-manager.js';
-import { cloneDiagramRepos, describeRepoScope, } from '../diagram-shared/clone-repos.js';
-import { fetchProductBasics } from '../find-shared/mcp.js';
-import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
-import { createDataFlowCaptureState, createDataFlowMcpServer, validateConsistency, } from './mcp-server.js';
-import { createDataFlowSystemPrompt, createDataFlowUserPrompt, } from './prompts.js';
-import { isDataFlowExtraction, } from './types.js';
-const WORKSPACE_KEY = 'data-flow';
-const MAX_TURNS = 150;
-// Auto-layout: simple grid; users can drag afterwards and we persist positions.
-const COLUMN_WIDTH = 320;
-const ROW_HEIGHT = 220;
-const COLUMNS = 4;
-export async function runDataFlowPhase(options) {
-    const { productId, repoId, diagramId, 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 markDiagramRunning(supabase, diagramId);
-    const repositoryIds = await getDiagramRepositoryIds(supabase, diagramId);
-    const cloneResult = await cloneDiagramRepos({
-        productId,
-        repoId,
-        repositoryIds,
-        workspaceKey: WORKSPACE_KEY,
-        verbose,
-    });
-    if (!cloneResult.ok) {
-        await markDiagramFailed(supabase, diagramId, cloneResult.message);
-        return { status: 'error', message: cloneResult.message };
-    }
-    const { projectDir, cleanupDir, repos } = cloneResult;
-    let succeeded = false;
-    try {
-        const product = repoOnly
-            ? await resolveRepoBasics(repoId, repos)
-            : await fetchProductBasics(productId);
-        const systemPrompt = await createDataFlowSystemPrompt({
-            projectDir,
-            hasCodebase: true,
-        });
-        const repoScope = describeRepoScope(repos);
-        const userPrompt = createDataFlowUserPrompt({
-            productName: product.name,
-            productDescription: product.description,
-            guidance: [guidance, repoScope].filter(Boolean).join('\n\n') || undefined,
-        });
-        logInfo('Running Claude data-flow extraction...');
-        const captureState = createDataFlowCaptureState();
-        const mcpServer = createDataFlowMcpServer(captureState, {
-            onProgress: ({ phase, message }) => {
-                logInfo(`[${phase}] ${message}`);
-            },
-        });
-        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: projectDir,
-                mcpServers: {
-                    'data-flow': mcpServer,
-                },
-            },
-        })) {
-            const { assistantBuffer, extraction: nextExtraction } = processSdkMessage(message, lastAssistantResponse, captureState, verbose);
-            lastAssistantResponse = assistantBuffer;
-            if (nextExtraction) {
-                extraction = nextExtraction;
-            }
-        }
-        if (!extraction) {
-            const msg = 'Data flow extraction failed: agent did not call submit_data_flow and no parseable data_flow block was found in the response';
-            await markDiagramFailed(supabase, diagramId, msg);
-            return { status: 'error', message: msg };
-        }
-        logInfo(`Extraction produced ${extraction.nodes.length} nodes / ${extraction.edges.length} connections`);
-        const { nodesCreated, edgesCreated } = await persistDiagram(supabase, diagramId, extraction);
-        await markDiagramSuccess(supabase, diagramId, extraction.summary);
-        succeeded = true;
-        logSuccess(`Data flow generated: ${nodesCreated} nodes, ${edgesCreated} connections`);
-        return {
-            status: 'success',
-            message: `Data flow generated (${nodesCreated} nodes, ${edgesCreated} connections)`,
-            nodesCreated,
-            edgesCreated,
-            summary: extraction.summary,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Data flow failed: ${errorMessage}`);
-        await markDiagramFailed(supabase, diagramId, errorMessage);
-        return { status: 'error', message: errorMessage };
-    }
-    finally {
-        if (succeeded) {
-            cleanupIssueRepo(cleanupDir);
-        }
-    }
-}
-/**
- * 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 diagram was scoped to (may be empty). */
-async function getDiagramRepositoryIds(supabase, diagramId) {
-    const { data } = await supabase
-        .from('diagrams')
-        .select('repository_ids')
-        .eq('id', diagramId)
-        .single();
-    return (data?.repository_ids ?? []).filter(Boolean);
-}
-function processSdkMessage(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-message, assistantBuffer, captureState, verbose) {
-    if (message.type === 'assistant') {
-        const next = assistantBuffer +
-            extractTextFromContent(message.message?.content ?? [], verbose);
-        return { assistantBuffer: next, extraction: null };
-    }
-    if (message.type === 'user' && verbose) {
-        const userContent = message.message?.content;
-        if (Array.isArray(userContent)) {
-            extractTextFromContent(userContent, verbose);
-        }
-        return { assistantBuffer, extraction: null };
-    }
-    if (message.type !== 'result') {
-        return { assistantBuffer, extraction: null };
-    }
-    if (captureState.captured) {
-        return { assistantBuffer, extraction: captureState.captured };
-    }
-    const fallback = tryFallbackParse(message, assistantBuffer);
-    if (fallback) {
-        logWarning('Agent emitted a fenced data_flow block instead of calling submit_data_flow; using the parsed text as a fallback.');
-        return { assistantBuffer, extraction: fallback };
-    }
-    if (message.subtype !== 'success') {
-        logError(`Extraction incomplete: ${message.subtype}`);
-    }
-    return { assistantBuffer, extraction: null };
-}
-function tryFallbackParse(resultMessage, assistantText) {
-    const responseText = resultMessage.subtype === 'success'
-        ? resultMessage.result || assistantText
-        : assistantText;
-    const parsed = tryExtractResult(responseText, 'data_flow');
-    if (!isDataFlowExtraction(parsed)) {
-        return null;
-    }
-    const { error } = validateConsistency(parsed);
-    if (error) {
-        logWarning(`Fallback extraction failed consistency check: ${error}`);
-        return null;
-    }
-    return parsed;
-}
-// ============================================================================
-// Persistence
-// ============================================================================
-async function markDiagramRunning(supabase, diagramId) {
-    const { error } = await supabase
-        .from('diagrams')
-        .update({ status: 'running', error: null })
-        .eq('id', diagramId);
-    if (error) {
-        logWarning(`Could not mark diagram as running: ${error.message}`);
-    }
-}
-async function markDiagramFailed(supabase, diagramId, errorMessage) {
-    await supabase
-        .from('diagrams')
-        .update({
-        status: 'failed',
-        error: errorMessage,
-        completed_at: new Date().toISOString(),
-    })
-        .eq('id', diagramId);
-}
-async function markDiagramSuccess(supabase, diagramId, summary) {
-    await supabase
-        .from('diagrams')
-        .update({
-        status: 'success',
-        summary,
-        error: null,
-        completed_at: new Date().toISOString(),
-    })
-        .eq('id', diagramId);
-}
-async function persistDiagram(supabase, diagramId, extraction) {
-    await supabase.from('diagram_edges').delete().eq('diagram_id', diagramId);
-    await supabase.from('diagram_nodes').delete().eq('diagram_id', diagramId);
-    if (extraction.nodes.length === 0) {
-        return { nodesCreated: 0, edgesCreated: 0 };
-    }
-    const nodeRows = extraction.nodes.map((n, i) => buildNodeRow(diagramId, n, i));
-    const { data: insertedNodes, error: nodesError } = await supabase
-        .from('diagram_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(diagramId, e, slugToId))
-        .filter((e) => e !== null);
-    if (edgeRows.length > 0) {
-        const { error: edgesError } = await supabase
-            .from('diagram_edges')
-            .insert(edgeRows);
-        if (edgesError) {
-            throw new Error(`Failed to insert edges: ${edgesError.message}`);
-        }
-    }
-    return {
-        nodesCreated: nodeRows.length,
-        edgesCreated: edgeRows.length,
-    };
-}
-function buildNodeRow(diagramId, node, index) {
-    return {
-        diagram_id: diagramId,
-        slug: node.slug,
-        name: node.name,
-        kind: node.kind,
-        schema: node,
-        position_x: (index % COLUMNS) * COLUMN_WIDTH,
-        position_y: Math.floor(index / COLUMNS) * ROW_HEIGHT,
-    };
-}
-function buildEdgeRow(diagramId, edge, slugToId) {
-    const fromId = slugToId.get(edge.fromSlug);
-    const toId = slugToId.get(edge.toSlug);
-    if (!fromId || !toId) {
-        return null;
-    }
-    return {
-        diagram_id: diagramId,
-        from_node_id: fromId,
-        to_node_id: toId,
-        label: edge.label ?? null,
-        source_anchor: edge.sourceFile ?? null,
-        kind: edge.kind,
-    };
-}

package/dist/phases/data-flow/mcp-server.d.ts

@@ -1,85 +0,0 @@
-/**
- * In-process MCP server for the data-flow phase. Exposes a single tool —
- * `submit_data_flow` — that the agent calls with the structured extraction,
- * plus `record_progress` for streaming status messages.
- *
- * Mirrors the shape of phases/screen-flow/mcp-server.ts; see that file for
- * the design rationale (zod schema + cross-field consistency + capture state).
- */
-import { z } from 'zod';
-import type { DataFlowExtraction } from './types.js';
-export interface DataFlowCaptureState {
-    captured: DataFlowExtraction | null;
-}
-export declare function createDataFlowCaptureState(): DataFlowCaptureState;
-export type DataFlowProgressSink = (event: {
-    phase: 'detection' | 'enumeration' | 'nodes' | 'edges' | 'submission';
-    message: string;
-}) => void;
-export declare function validateConsistency(extraction: DataFlowExtraction): {
-    error: string | null;
-};
-export declare function createSubmitDataFlowTool(state: DataFlowCaptureState): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
-    summary: z.ZodString;
-    nodes: z.ZodArray<z.ZodObject<{
-        slug: z.ZodString;
-        name: z.ZodString;
-        kind: z.ZodEnum<{
-            source: "source";
-            model: "model";
-            transform: "transform";
-            dataset: "dataset";
-            sink: "sink";
-            queue: "queue";
-        }>;
-        file: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        tech: z.ZodOptional<z.ZodString>;
-        schedule: z.ZodOptional<z.ZodString>;
-        inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            type: z.ZodOptional<z.ZodString>;
-            required: z.ZodOptional<z.ZodBoolean>;
-            description: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-        outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            type: z.ZodOptional<z.ZodString>;
-            required: z.ZodOptional<z.ZodBoolean>;
-            description: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-        sample: z.ZodOptional<z.ZodObject<{
-            columns: z.ZodArray<z.ZodString>;
-            rows: z.ZodArray<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-        stats: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            label: z.ZodString;
-            value: z.ZodString;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>;
-    edges: z.ZodArray<z.ZodObject<{
-        fromSlug: z.ZodString;
-        toSlug: z.ZodString;
-        kind: z.ZodEnum<{
-            data: "data";
-            event: "event";
-            control: "control";
-            derives: "derives";
-        }>;
-        label: z.ZodOptional<z.ZodString>;
-        sourceFile: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}>;
-export declare function createRecordProgressTool(sink?: DataFlowProgressSink): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
-    phase: z.ZodEnum<{
-        nodes: "nodes";
-        edges: "edges";
-        detection: "detection";
-        enumeration: "enumeration";
-        submission: "submission";
-    }>;
-    message: z.ZodString;
-}>;
-export declare function createDataFlowMcpServer(state: DataFlowCaptureState, options?: {
-    onProgress?: DataFlowProgressSink;
-}): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;

package/dist/phases/data-flow/mcp-server.js

@@ -1,140 +0,0 @@
-/**
- * In-process MCP server for the data-flow phase. Exposes a single tool —
- * `submit_data_flow` — that the agent calls with the structured extraction,
- * plus `record_progress` for streaming status messages.
- *
- * Mirrors the shape of phases/screen-flow/mcp-server.ts; see that file for
- * the design rationale (zod schema + cross-field consistency + capture state).
- */
-import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
-import { z } from 'zod';
-export function createDataFlowCaptureState() {
-    return { captured: null };
-}
-// ---------------------------------------------------------------------------
-// Zod schemas (mirror types.ts)
-// ---------------------------------------------------------------------------
-const dataFieldSchema = z.object({
-    name: z.string().min(1),
-    type: z.string().optional(),
-    required: z.boolean().optional(),
-    description: z.string().optional(),
-});
-const dataSampleSchema = z.object({
-    columns: z.array(z.string()),
-    rows: z.array(z.array(z.string())),
-});
-const dataStatSchema = z.object({
-    label: z.string(),
-    value: z.string(),
-});
-const dataNodeSchema = z.object({
-    slug: z.string().min(1),
-    name: z.string().min(1),
-    kind: z.enum(['source', 'dataset', 'transform', 'sink', 'queue', 'model']),
-    file: z.string().optional(),
-    description: z.string().optional(),
-    tech: z.string().optional(),
-    schedule: z.string().optional(),
-    inputs: z.array(dataFieldSchema).optional(),
-    outputs: z.array(dataFieldSchema).optional(),
-    sample: dataSampleSchema.optional(),
-    stats: z.array(dataStatSchema).optional(),
-});
-const dataEdgeSchema = z.object({
-    fromSlug: z.string().min(1),
-    toSlug: z.string().min(1),
-    kind: z.enum(['data', 'event', 'control', 'derives']),
-    label: z.string().optional(),
-    sourceFile: z.string().optional(),
-});
-export function validateConsistency(extraction) {
-    const slugs = new Set();
-    for (const node of extraction.nodes) {
-        if (slugs.has(node.slug)) {
-            return {
-                error: `Duplicate node slug "${node.slug}". Each node.slug MUST be unique within the diagram. Re-call submit_data_flow with deduplicated nodes.`,
-            };
-        }
-        slugs.add(node.slug);
-    }
-    for (const edge of extraction.edges) {
-        if (!slugs.has(edge.fromSlug)) {
-            return {
-                error: `Edge fromSlug "${edge.fromSlug}" → "${edge.toSlug}" does not match any node slug. Either add the missing node or drop the edge, then re-call submit_data_flow.`,
-            };
-        }
-        if (!slugs.has(edge.toSlug)) {
-            return {
-                error: `Edge fromSlug "${edge.fromSlug}" → toSlug "${edge.toSlug}" does not match any node slug. Either add the missing node or drop the edge, then re-call submit_data_flow.`,
-            };
-        }
-    }
-    return { error: null };
-}
-export function createSubmitDataFlowTool(state) {
-    return tool('submit_data_flow', [
-        'Submit the final data flow extraction. Call this EXACTLY once,',
-        'when you have finished mapping every data node and connection. Pass',
-        'the full structured flow as the argument. After this call succeeds,',
-        'end your turn — do NOT also paste the same data as a fenced code',
-        'block. If validation fails, the error message tells you what to fix;',
-        'call the tool again with corrected data.',
-    ].join(' '), {
-        summary: z
-            .string()
-            .min(1)
-            .describe('1-3 sentence narrative of what this system does with data and the primary pipelines.'),
-        nodes: z
-            .array(dataNodeSchema)
-            .describe('Every data node: source / dataset / transform / sink / queue / model. node.slug MUST be unique within the diagram.'),
-        edges: z
-            .array(dataEdgeSchema)
-            .describe('Connections. fromSlug = upstream, toSlug = downstream. Every fromSlug / toSlug MUST reference a slug present in nodes; drop edges whose endpoints you did not emit.'),
-    }, async (args) => {
-        const extraction = {
-            summary: args.summary,
-            nodes: args.nodes,
-            edges: args.edges,
-        };
-        const { error } = validateConsistency(extraction);
-        if (error) {
-            return {
-                content: [{ type: 'text', text: error }],
-                isError: true,
-            };
-        }
-        state.captured = extraction;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Captured ${extraction.nodes.length} data nodes / ${extraction.edges.length} connections. End your turn now.`,
-                },
-            ],
-        };
-    });
-}
-export function createRecordProgressTool(sink) {
-    return tool('record_progress', 'Send a short status update to the user. Does not affect the extraction. Call it at each phase boundary so the user sees progress.', {
-        phase: z
-            .enum(['detection', 'enumeration', 'nodes', 'edges', 'submission'])
-            .describe('Which phase the message belongs to.'),
-        message: z.string().min(1).describe('Human-readable status update.'),
-    }, async (args) => {
-        sink?.({ phase: args.phase, message: args.message });
-        return {
-            content: [{ type: 'text', text: 'ok' }],
-        };
-    });
-}
-export function createDataFlowMcpServer(state, options) {
-    return createSdkMcpServer({
-        name: 'data-flow',
-        version: '1.0.0',
-        tools: [
-            createSubmitDataFlowTool(state),
-            createRecordProgressTool(options?.onProgress),
-        ],
-    });
-}

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

@@ -1,14 +0,0 @@
-/**
- * Prompts for the data-flow phase. Loads the system prompt body from
- * `skills/phase/data-flow/SKILL.md` (with optional project override) and
- * appends the JSON output contract.
- */
-export declare function createDataFlowSystemPrompt(options?: {
-    projectDir?: string;
-    hasCodebase?: boolean;
-}): Promise<string>;
-export declare function createDataFlowUserPrompt(args: {
-    productName: string;
-    productDescription?: string;
-    guidance?: string;
-}): string;

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

@@ -1,36 +0,0 @@
-/**
- * Prompts for the data-flow phase. Loads the system prompt body from
- * `skills/phase/data-flow/SKILL.md` (with optional project override) and
- * appends the JSON output contract.
- */
-import { processConditionals, resolveSkill, } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export async function createDataFlowSystemPrompt(options) {
-    const skill = await resolveSkill('phase/data-flow', {
-        projectDir: options?.projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/data-flow');
-    }
-    const prompt = processConditionals(skill.prompt, {
-        hasCodebase: options?.hasCodebase ?? true,
-    });
-    return `${prompt}
-
-${OUTPUT_CONTRACTS['data-flow']}`;
-}
-export function createDataFlowUserPrompt(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 data flow for **${args.productName}**.${descBlock}${guidanceBlock}
-
-Start by detecting the stack (check package.json / pyproject.toml / go.mod / Cargo.toml / requirements.txt etc.), then look for: ETL/pipeline definitions, database migrations or schema files, queue/topic configs, model invocation sites, file ingest scripts. Read just enough source per node to fill in a useful DataNodeSchema — do not need to read everything.
-
-Call \`mcp__data-flow__record_progress\` at each phase boundary so the user can see your progress (otherwise the CLI looks frozen).
-
-When you are done, return the result by **calling the \`mcp__data-flow__submit_data_flow\` tool exactly once** with \`summary\`, \`nodes\`, and \`edges\` as arguments. Do not paste the JSON as a fenced text block — the tool call is the deliverable. If the tool returns an error, fix the issue it describes and call the tool again.`;
-}

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

@@ -1,71 +0,0 @@
-/**
- * Data Flow domain types.
- *
- * A DataNodeSchema is a structured description of one unit of data state or
- * computation in a product — a source, dataset, transform, sink, queue, or
- * model. The CLI extracts these from source code (pipeline definitions,
- * schema files, queue handlers, etc.) and the desktop renders them with a
- * unified <DataNodePreview> component.
- *
- * Companion to ScreenSchema: same flow-graph shape (nodes + edges with a
- * shared `diagrams` table storing the JSONB schema), different domain. Data
- * flow edges describe how data moves between nodes, not user navigation.
- */
-export type DataNodeKind = 'source' | 'dataset' | 'transform' | 'sink' | 'queue' | 'model';
-export interface DataField {
-    name: string;
-    type?: string;
-    required?: boolean;
-    description?: string;
-}
-export interface DataSample {
-    columns: string[];
-    rows: string[][];
-}
-export interface DataStat {
-    label: string;
-    value: string;
-}
-export interface DataNodeSchema {
-    /** Stable slug within the flow (e.g. 'raw-events', 'enrich-user'). */
-    slug: string;
-    /** Human-readable name. */
-    name: string;
-    kind: DataNodeKind;
-    /** Source file path (jump anchor); for datasets, the schema/migration file. */
-    file?: string;
-    /** One-sentence description. */
-    description?: string;
-    /** Technology/format hint: 'postgres', 'parquet', 'kafka', 'openai-api', etc. */
-    tech?: string;
-    /** For transforms: 'cron 0 0 * * *', 'on-event', 'manual', 'continuous'. */
-    schedule?: string;
-    /** Schema of inputs the node consumes. */
-    inputs?: DataField[];
-    /** Schema of outputs the node produces. */
-    outputs?: DataField[];
-    /** Tiny realistic sample (≤ 4 rows) for datasets. */
-    sample?: DataSample;
-    /** Volume / latency hints — free-form key/value pairs. */
-    stats?: DataStat[];
-}
-/**
- * Edge kinds. Direction is always "data movement": fromSlug = upstream,
- * toSlug = downstream. The kind describes the *nature* of the connection.
- */
-export type DataEdgeKind = 'data' | 'event' | 'control' | 'derives';
-export interface DataEdge {
-    fromSlug: string;
-    toSlug: string;
-    kind: DataEdgeKind;
-    /** Free-form descriptor: 'nightly batch', 'on user signup', 'embedding'. */
-    label?: string;
-    /** File containing the connection definition (when distinct from from-node's file). */
-    sourceFile?: string;
-}
-export interface DataFlowExtraction {
-    summary: string;
-    nodes: DataNodeSchema[];
-    edges: DataEdge[];
-}
-export declare function isDataFlowExtraction(value: unknown): value is DataFlowExtraction;