edsger 0.77.0 → 0.79.0

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

@@ -1,86 +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.
- */
-// ============================================================================
-// Runtime validation for AI-produced extraction
-// ============================================================================
-const NODE_KINDS = new Set([
-    'source',
-    'dataset',
-    'transform',
-    'sink',
-    'queue',
-    'model',
-]);
-const EDGE_KINDS = new Set([
-    'data',
-    'event',
-    'control',
-    'derives',
-]);
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-function isDataNodeSchema(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    if (typeof value.slug !== 'string' || value.slug.length === 0) {
-        return false;
-    }
-    if (typeof value.name !== 'string' || value.name.length === 0) {
-        return false;
-    }
-    if (typeof value.kind !== 'string' ||
-        !NODE_KINDS.has(value.kind)) {
-        return false;
-    }
-    return true;
-}
-function isDataEdge(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    if (typeof value.fromSlug !== 'string') {
-        return false;
-    }
-    if (typeof value.toSlug !== 'string') {
-        return false;
-    }
-    if (typeof value.kind !== 'string' ||
-        !EDGE_KINDS.has(value.kind)) {
-        return false;
-    }
-    return true;
-}
-export function isDataFlowExtraction(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    if (typeof value.summary !== 'string') {
-        return false;
-    }
-    if (!Array.isArray(value.nodes)) {
-        return false;
-    }
-    if (!Array.isArray(value.edges)) {
-        return false;
-    }
-    if (!value.nodes.every(isDataNodeSchema)) {
-        return false;
-    }
-    if (!value.edges.every(isDataEdge)) {
-        return false;
-    }
-    return true;
-}

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

@@ -1,63 +0,0 @@
-/**
- * Shared multi-repo cloning for flow generation (screen-flow / data-flow).
- *
- * A flow can be scoped to one or several repositories (the user picks them in
- * the desktop UI; the chosen set is stored on `diagrams.repository_ids`). This
- * helper resolves that set, clones each repo into a per-flow parent workspace
- * directory, and returns the directory the agent should run against:
- *   - single repo  → the repo's own clone dir
- *   - many repos   → the parent dir holding every clone as a subdirectory,
- *                    so the agent can explore them all and produce one unified
- *                    flow.
- *
- * Falls back to the product's primary repo when `repository_ids` is empty
- * (older diagrams, or single-repo products).
- */
-export interface ClonedRepo {
-    fullName: string;
-    owner: string;
-    repo: string;
-    dir: string;
-}
-export interface CloneFlowReposSuccess {
-    ok: true;
-    /** Directory to point the agent at (parent dir for multi-repo). */
-    projectDir: string;
-    /** Directory to clean up afterwards (always the per-flow parent). */
-    cleanupDir: string;
-    repos: ClonedRepo[];
-}
-export interface CloneFlowReposFailure {
-    ok: false;
-    message: string;
-}
-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 | undefined, repositoryIds: string[], fallback?: {
-    owner: string;
-    repo: string;
-}): Promise<{
-    fullName: string;
-    owner: string;
-    repo: string;
-}[]>;
-export declare function cloneDiagramRepos(opts: {
-    /** 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;
-}): Promise<CloneFlowReposSuccess | CloneFlowReposFailure>;
-/**
- * Build a short note describing the repo scope, appended to the agent's user
- * prompt so it knows whether to map one repo or unify several.
- */
-export declare function describeRepoScope(repos: ClonedRepo[]): string;

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

@@ -1,153 +0,0 @@
-/**
- * Shared multi-repo cloning for flow generation (screen-flow / data-flow).
- *
- * A flow can be scoped to one or several repositories (the user picks them in
- * the desktop UI; the chosen set is stored on `diagrams.repository_ids`). This
- * helper resolves that set, clones each repo into a per-flow parent workspace
- * directory, and returns the directory the agent should run against:
- *   - single repo  → the repo's own clone dir
- *   - many repos   → the parent dir holding every clone as a subdirectory,
- *                    so the agent can explore them all and produce one unified
- *                    flow.
- *
- * Falls back to the product's primary repo when `repository_ids` is empty
- * (older diagrams, or single-repo products).
- */
-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';
-export function safeDirName(fullName) {
-    return fullName.replace(/[^a-zA-Z0-9._-]/g, '_');
-}
-/**
- * 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) {
-        if (fallback) {
-            return [
-                {
-                    fullName: `${fallback.owner}/${fallback.repo}`,
-                    owner: fallback.owner,
-                    repo: fallback.repo,
-                },
-            ];
-        }
-        return [];
-    }
-    const supabase = getSupabase();
-    const { data } = await supabase
-        .from('repositories')
-        .select('id, full_name')
-        .in('id', repositoryIds);
-    const byId = new Map((data ?? []).map((r) => [r.id, r.full_name]));
-    // Preserve the caller's order (diagrams.repository_ids is ordered).
-    const resolved = [];
-    for (const id of repositoryIds) {
-        const fullName = byId.get(id);
-        if (!fullName) {
-            continue;
-        }
-        const [owner, repo] = fullName.split('/');
-        if (!owner || !repo) {
-            continue;
-        }
-        resolved.push({ fullName, owner, repo });
-    }
-    // If none resolved (deleted repos / RLS), fall back to the primary repo so
-    // generation still produces something useful (product mode only).
-    if (resolved.length === 0 && fallback) {
-        return [
-            {
-                fullName: `${fallback.owner}/${fallback.repo}`,
-                owner: fallback.owner,
-                repo: fallback.repo,
-            },
-        ];
-    }
-    return resolved;
-}
-export async function cloneDiagramRepos(opts) {
-    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 ||
-                (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 workspaceRoot = ensureWorkspaceDir();
-    const parentDir = getIssueRepoPath(workspaceRoot, `${workspaceKey}-${repoOnly ? `repo-${repoId}` : productId}`);
-    const repos = [];
-    for (const target of targets) {
-        try {
-            // The product-level token (installation or user PAT/OAuth) is reused for
-            // every repo; if it can't access one, that clone fails and we skip it
-            // rather than aborting the whole generation.
-            const { repoPath } = cloneIssueRepo(parentDir, safeDirName(target.fullName), target.owner, target.repo, gh.token);
-            repos.push({
-                fullName: target.fullName,
-                owner: target.owner,
-                repo: target.repo,
-                dir: repoPath,
-            });
-        }
-        catch (err) {
-            logWarning(`Skipping ${target.fullName}: clone failed (${err instanceof Error ? err.message : String(err)})`);
-        }
-    }
-    if (repos.length === 0) {
-        return {
-            ok: false,
-            message: 'Failed to clone any of the selected repositories.',
-        };
-    }
-    if (repos.length > 1) {
-        logInfo(`Cloned ${repos.length} repos for ${workspaceKey}: ${repos.map((r) => r.fullName).join(', ')}`);
-    }
-    return {
-        ok: true,
-        // Single repo: run directly in its dir. Multi-repo: run in the parent so
-        // the agent sees every clone as a subdirectory.
-        projectDir: repos.length === 1 ? repos[0].dir : parentDir,
-        cleanupDir: parentDir,
-        repos,
-    };
-}
-/**
- * Build a short note describing the repo scope, appended to the agent's user
- * prompt so it knows whether to map one repo or unify several.
- */
-export function describeRepoScope(repos) {
-    if (repos.length <= 1) {
-        return '';
-    }
-    const list = repos.map((r) => `- ${r.fullName} (subdirectory: ${safeDirName(r.fullName)})`);
-    return [
-        `This product spans ${repos.length} repositories, each cloned into its own subdirectory of the working directory:`,
-        ...list,
-        'Explore all of them and produce a single unified flow that spans the repositories.',
-    ].join('\n');
-}

package/dist/phases/diagram-shared/generate.d.ts

@@ -1,42 +0,0 @@
-/**
- * Shared diagram generation runner.
- *
- * Encapsulates the common pipeline every node/edge diagram phase uses: clone
- * the repo(s), resolve product/repo basics, build prompts, run the Claude
- * Agent SDK loop with an in-process MCP capture server, fall back to a fenced
- * block if the agent forgot the tool, then persist to the diagrams tables and
- * flip status. Each lean phase just supplies its domain MCP config + prompts.
- */
-import { type DiagramMcpConfig } from './mcp.js';
-export interface GenerateDiagramOptions {
-    productId?: string;
-    repoId?: string;
-    diagramId: string;
-    guidance?: string;
-    verbose?: boolean;
-    /** Workspace clone key, e.g. 'state-diagram'. */
-    workspaceKey: string;
-    /** Fenced block name for the fallback parser, e.g. 'state_diagram'. */
-    fenceName: string;
-    /** Plural noun for log/result messages, e.g. 'states', 'classes'. */
-    nounPlural: string;
-    edgeNounPlural: string;
-    mcpConfig: DiagramMcpConfig;
-    buildSystemPrompt: (args: {
-        projectDir: string;
-        hasCodebase: boolean;
-    }) => Promise<string>;
-    buildUserPrompt: (args: {
-        productName: string;
-        productDescription?: string;
-        guidance?: string;
-    }) => string;
-}
-export interface DiagramPhaseResult {
-    status: 'success' | 'error';
-    message: string;
-    nodesCreated?: number;
-    edgesCreated?: number;
-    summary?: string;
-}
-export declare function generateDiagram(options: GenerateDiagramOptions): Promise<DiagramPhaseResult>;

package/dist/phases/diagram-shared/generate.js

@@ -1,162 +0,0 @@
-/**
- * Shared diagram generation runner.
- *
- * Encapsulates the common pipeline every node/edge diagram phase uses: clone
- * the repo(s), resolve product/repo basics, build prompts, run the Claude
- * Agent SDK loop with an in-process MCP capture server, fall back to a fenced
- * block if the agent forgot the tool, then persist to the diagrams tables and
- * flip status. Each lean phase just supplies its domain MCP config + prompts.
- */
-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 { fetchProductBasics } from '../find-shared/mcp.js';
-import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
-import { cloneDiagramRepos, describeRepoScope } from './clone-repos.js';
-import { getDiagramRepositoryIds, isDiagramExtraction, markDiagramFailed, markDiagramRunning, markDiagramSuccess, persistDiagramGraph, validateGraphConsistency, } from './graph.js';
-import { createDiagramCaptureState, createDiagramMcpServer, } from './mcp.js';
-const MAX_TURNS = 150;
-export async function generateDiagram(options) {
-    const { productId, repoId, diagramId, guidance, verbose } = options;
-    const repoOnly = !productId && Boolean(repoId);
-    const label = options.mcpConfig.name;
-    logInfo(productId
-        ? `Starting ${label} generation for product ${productId}`
-        : `Starting ${label} 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: options.workspaceKey,
-        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 options.buildSystemPrompt({
-            projectDir,
-            hasCodebase: true,
-        });
-        const repoScope = describeRepoScope(repos);
-        const userPrompt = options.buildUserPrompt({
-            productName: product.name,
-            productDescription: product.description,
-            guidance: [guidance, repoScope].filter(Boolean).join('\n\n') || undefined,
-        });
-        logInfo(`Running Claude ${label} extraction...`);
-        const captureState = createDiagramCaptureState();
-        const mcpServer = createDiagramMcpServer(options.mcpConfig, captureState, {
-            onProgress: ({ phase, message }) => logInfo(`[${phase}] ${message}`),
-        });
-        let assistantBuffer = '';
-        let extraction = null;
-        const stream = query({
-            prompt: createPromptGenerator(userPrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model: DEFAULT_MODEL,
-                maxTurns: MAX_TURNS,
-                permissionMode: 'bypassPermissions',
-                cwd: projectDir,
-                mcpServers: { [options.mcpConfig.name]: mcpServer },
-            },
-        });
-        for await (const rawMessage of stream) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const message = rawMessage;
-            if (message.type === 'assistant') {
-                assistantBuffer += extractTextFromContent(message.message?.content ?? [], verbose);
-                continue;
-            }
-            if (message.type === 'user' && verbose) {
-                const userContent = message.message?.content;
-                if (Array.isArray(userContent)) {
-                    extractTextFromContent(userContent, verbose);
-                }
-                continue;
-            }
-            if (message.type !== 'result') {
-                continue;
-            }
-            if (captureState.captured) {
-                extraction = captureState.captured;
-                break;
-            }
-            const fallback = tryFallbackParse(message, assistantBuffer, options.fenceName);
-            if (fallback) {
-                logWarning(`Agent emitted a fenced ${options.fenceName} block instead of calling the submit tool; using the parsed text as a fallback.`);
-                extraction = fallback;
-            }
-            else if (message.subtype !== 'success') {
-                logError(`Extraction incomplete: ${message.subtype}`);
-            }
-        }
-        if (!extraction) {
-            const msg = `${label} extraction failed: agent did not call the submit tool and no parseable ${options.fenceName} block was found.`;
-            await markDiagramFailed(supabase, diagramId, msg);
-            return { status: 'error', message: msg };
-        }
-        logInfo(`Extraction produced ${extraction.nodes.length} ${options.nounPlural} / ${extraction.edges.length} ${options.edgeNounPlural}`);
-        const { nodesCreated, edgesCreated } = await persistDiagramGraph(supabase, diagramId, extraction);
-        await markDiagramSuccess(supabase, diagramId, extraction.summary);
-        succeeded = true;
-        logSuccess(`${label} generated: ${nodesCreated} ${options.nounPlural}, ${edgesCreated} ${options.edgeNounPlural}`);
-        return {
-            status: 'success',
-            message: `${label} generated (${nodesCreated} ${options.nounPlural}, ${edgesCreated} ${options.edgeNounPlural})`,
-            nodesCreated,
-            edgesCreated,
-            summary: extraction.summary,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`${label} failed: ${errorMessage}`);
-        await markDiagramFailed(supabase, diagramId, errorMessage);
-        return { status: 'error', message: errorMessage };
-    }
-    finally {
-        if (succeeded) {
-            cleanupIssueRepo(cleanupDir);
-        }
-    }
-}
-async function resolveRepoBasics(repositoryId, repos) {
-    const basics = await getRepositoryBasics(repositoryId).catch(() => null);
-    return {
-        name: basics?.fullName ?? repos[0]?.fullName ?? repositoryId,
-        description: basics?.description ?? undefined,
-    };
-}
-function tryFallbackParse(resultMessage, assistantText, fenceName) {
-    const responseText = resultMessage.subtype === 'success'
-        ? resultMessage.result || assistantText
-        : assistantText;
-    const parsed = tryExtractResult(responseText, fenceName);
-    if (!isDiagramExtraction(parsed)) {
-        return null;
-    }
-    const { error } = validateGraphConsistency(parsed);
-    if (error) {
-        logWarning(`Fallback extraction failed consistency check: ${error}`);
-        return null;
-    }
-    return parsed;
-}

package/dist/phases/diagram-shared/graph.d.ts

@@ -1,62 +0,0 @@
-/**
- * Shared graph model + persistence for node/edge diagram types.
- *
- * Every diagram type (screen / data / er / sequence and the lean types built
- * on this framework — state / class / architecture / flowchart) is a graph of
- * nodes + edges stored in the generic `diagrams` / `diagram_nodes` /
- * `diagram_edges` tables, discriminated by `diagrams.type`. This module owns
- * the type-agnostic extraction shape, its consistency validation, and the
- * persistence + status-transition helpers so each phase only has to describe
- * its own domain schema and prompts.
- */
-import type { SupabaseClient } from '@supabase/supabase-js';
-/** One node in a diagram. Domain-specific fields ride along and are stored
- *  verbatim in `diagram_nodes.schema`. */
-export interface GraphNode {
-    /** Stable slug, unique within the diagram. */
-    slug: string;
-    name: string;
-    kind: string;
-    [key: string]: unknown;
-}
-/** One directed edge. fromSlug → toSlug must reference emitted node slugs. */
-export interface GraphEdge {
-    fromSlug: string;
-    toSlug: string;
-    kind: string;
-    label?: string;
-    /** File (jump-to-code) for the connection, stored as source_anchor. */
-    sourceFile?: string;
-    /** Extra per-edge data stored in diagram_edges.metadata (order, columns…). */
-    metadata?: Record<string, unknown>;
-}
-export interface DiagramExtraction {
-    summary: string;
-    nodes: GraphNode[];
-    edges: GraphEdge[];
-}
-export declare function isGraphNode(value: unknown): value is GraphNode;
-export declare function isGraphEdge(value: unknown): value is GraphEdge;
-export declare function isDiagramExtraction(value: unknown): value is DiagramExtraction;
-/**
- * Cross-field checks: unique node slugs and every edge endpoint references a
- * node that was emitted. Returns a human-readable instruction on failure so
- * the agent can self-correct and re-submit.
- */
-export declare function validateGraphConsistency(extraction: DiagramExtraction): {
-    error: string | null;
-};
-export declare function markDiagramRunning(supabase: SupabaseClient, diagramId: string): Promise<void>;
-export declare function markDiagramFailed(supabase: SupabaseClient, diagramId: string, errorMessage: string): Promise<void>;
-export declare function markDiagramSuccess(supabase: SupabaseClient, diagramId: string, summary: string): Promise<void>;
-/** Read the ordered repo set a diagram was scoped to (may be empty). */
-export declare function getDiagramRepositoryIds(supabase: SupabaseClient, diagramId: string): Promise<string[]>;
-/**
- * Replace the diagram's nodes and edges with a freshly extracted graph.
- * Slugs are resolved to node ids for the edge foreign keys; edges whose
- * endpoints weren't emitted are dropped.
- */
-export declare function persistDiagramGraph(supabase: SupabaseClient, diagramId: string, extraction: DiagramExtraction): Promise<{
-    nodesCreated: number;
-    edgesCreated: number;
-}>;