edsger 0.76.0 → 0.78.0

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

@@ -1,169 +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 { logWarning } from '../../utils/logger.js';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-export function isGraphNode(value) {
-    return (isRecord(value) &&
-        typeof value.slug === 'string' &&
-        value.slug.length > 0 &&
-        typeof value.name === 'string' &&
-        value.name.length > 0 &&
-        typeof value.kind === 'string' &&
-        value.kind.length > 0);
-}
-export function isGraphEdge(value) {
-    return (isRecord(value) &&
-        typeof value.fromSlug === 'string' &&
-        typeof value.toSlug === 'string' &&
-        typeof value.kind === 'string');
-}
-export function isDiagramExtraction(value) {
-    return (isRecord(value) &&
-        typeof value.summary === 'string' &&
-        Array.isArray(value.nodes) &&
-        Array.isArray(value.edges) &&
-        value.nodes.every(isGraphNode) &&
-        value.edges.every(isGraphEdge));
-}
-/**
- * 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 function validateGraphConsistency(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-submit with deduplicated nodes.`,
-            };
-        }
-        slugs.add(node.slug);
-    }
-    for (const edge of extraction.edges) {
-        if (!slugs.has(edge.fromSlug)) {
-            return {
-                error: `Edge "${edge.fromSlug}" → "${edge.toSlug}": fromSlug does not match any node slug. Add the missing node or drop the edge, then re-submit.`,
-            };
-        }
-        if (!slugs.has(edge.toSlug)) {
-            return {
-                error: `Edge "${edge.fromSlug}" → "${edge.toSlug}": toSlug does not match any node slug. Add the missing node or drop the edge, then re-submit.`,
-            };
-        }
-    }
-    return { error: null };
-}
-// ============================================================================
-// Persistence
-// ============================================================================
-// Auto-layout grid; users drag afterwards and positions persist.
-const COLUMN_WIDTH = 320;
-const ROW_HEIGHT = 240;
-const COLUMNS = 4;
-export 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}`);
-    }
-}
-export async function markDiagramFailed(supabase, diagramId, errorMessage) {
-    await supabase
-        .from('diagrams')
-        .update({
-        status: 'failed',
-        error: errorMessage,
-        completed_at: new Date().toISOString(),
-    })
-        .eq('id', diagramId);
-}
-export async function markDiagramSuccess(supabase, diagramId, summary) {
-    await supabase
-        .from('diagrams')
-        .update({
-        status: 'success',
-        summary,
-        error: null,
-        completed_at: new Date().toISOString(),
-    })
-        .eq('id', diagramId);
-}
-/** Read the ordered repo set a diagram was scoped to (may be empty). */
-export async function getDiagramRepositoryIds(supabase, diagramId) {
-    const { data } = await supabase
-        .from('diagrams')
-        .select('repository_ids')
-        .eq('id', diagramId)
-        .single();
-    return (data?.repository_ids ?? []).filter(Boolean);
-}
-/**
- * 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 async function persistDiagramGraph(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((node, i) => ({
-        diagram_id: diagramId,
-        slug: node.slug,
-        name: node.name,
-        kind: node.kind,
-        schema: node,
-        position_x: (i % COLUMNS) * COLUMN_WIDTH,
-        position_y: Math.floor(i / COLUMNS) * ROW_HEIGHT,
-    }));
-    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((edge) => {
-        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,
-            metadata: edge.metadata ?? {},
-        };
-    })
-        .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 };
-}

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

@@ -1,35 +0,0 @@
-/**
- * Shared in-process MCP server builder for graph diagram types.
- *
- * Each lean diagram phase (state / class / architecture / flowchart) supplies
- * its own zod node/edge schemas + tool name; this assembles the standard
- * `submit_<type>` capture tool (validated against the shared graph consistency
- * rules) plus a `record_progress` status tool.
- */
-import { type ZodTypeAny } from 'zod';
-import { type DiagramExtraction } from './graph.js';
-export interface DiagramCaptureState {
-    captured: DiagramExtraction | null;
-}
-export declare function createDiagramCaptureState(): DiagramCaptureState;
-export type DiagramProgressSink = (event: {
-    phase: 'detection' | 'enumeration' | 'nodes' | 'edges' | 'submission';
-    message: string;
-}) => void;
-export interface DiagramMcpConfig {
-    /** Server name + submit tool become `submit_<toolName>`. */
-    name: string;
-    toolName: string;
-    summaryDescribe: string;
-    nodesSchema: ZodTypeAny;
-    nodesDescribe: string;
-    edgesSchema: ZodTypeAny;
-    edgesDescribe: string;
-}
-/**
- * Build the MCP server for one diagram type. The submit tool captures the
- * extraction into `state` after passing the shared consistency check.
- */
-export declare function createDiagramMcpServer(config: DiagramMcpConfig, state: DiagramCaptureState, options?: {
-    onProgress?: DiagramProgressSink;
-}): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;

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

@@ -1,68 +0,0 @@
-/**
- * Shared in-process MCP server builder for graph diagram types.
- *
- * Each lean diagram phase (state / class / architecture / flowchart) supplies
- * its own zod node/edge schemas + tool name; this assembles the standard
- * `submit_<type>` capture tool (validated against the shared graph consistency
- * rules) plus a `record_progress` status tool.
- */
-import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
-import { z } from 'zod';
-import { validateGraphConsistency, } from './graph.js';
-export function createDiagramCaptureState() {
-    return { captured: null };
-}
-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' }] };
-    });
-}
-/**
- * Build the MCP server for one diagram type. The submit tool captures the
- * extraction into `state` after passing the shared consistency check.
- */
-export function createDiagramMcpServer(config, state, options) {
-    const submitTool = tool(`submit_${config.toolName}`, [
-        `Submit the final ${config.name}. Call this EXACTLY once, when you have`,
-        'finished mapping every node and edge. After it succeeds, end your turn —',
-        'do NOT also paste the same data as a fenced code block. If validation',
-        'fails, the error tells you what to fix; call the tool again.',
-    ].join(' '), {
-        summary: z.string().min(1).describe(config.summaryDescribe),
-        nodes: config.nodesSchema.describe(config.nodesDescribe),
-        edges: config.edgesSchema.describe(config.edgesDescribe),
-    }, async (args) => {
-        const extraction = {
-            summary: args.summary,
-            nodes: args.nodes,
-            edges: args.edges,
-        };
-        const { error } = validateGraphConsistency(extraction);
-        if (error) {
-            return {
-                content: [{ type: 'text', text: error }],
-                isError: true,
-            };
-        }
-        state.captured = extraction;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Captured ${extraction.nodes.length} nodes / ${extraction.edges.length} edges. End your turn now.`,
-                },
-            ],
-        };
-    });
-    return createSdkMcpServer({
-        name: config.name,
-        version: '1.0.0',
-        tools: [submitTool, createRecordProgressTool(options?.onProgress)],
-    });
-}

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

@@ -1,23 +0,0 @@
-/**
- * Shared prompt builders for graph diagram phases. The system prompt loads the
- * type's SKILL.md (project-overridable) and appends its JSON output contract;
- * the user prompt wraps a type-specific task + process paragraph in the
- * standard "call the submit tool" envelope.
- */
-export declare function buildDiagramSystemPrompt(skillRef: string, contractKey: string, opts?: {
-    projectDir?: string;
-    hasCodebase?: boolean;
-}): Promise<string>;
-export declare function buildDiagramUserPrompt(args: {
-    /** e.g. "Map the state machine for". The product name is appended. */
-    task: string;
-    productName: string;
-    productDescription?: string;
-    guidance?: string;
-    /** One paragraph telling the agent what to scan / how to proceed. */
-    process: string;
-    /** MCP server name, e.g. 'state-diagram'. */
-    mcpName: string;
-    /** Submit tool suffix, e.g. 'state_diagram' → submit_state_diagram. */
-    toolName: string;
-}): string;

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

@@ -1,35 +0,0 @@
-/**
- * Shared prompt builders for graph diagram phases. The system prompt loads the
- * type's SKILL.md (project-overridable) and appends its JSON output contract;
- * the user prompt wraps a type-specific task + process paragraph in the
- * standard "call the submit tool" envelope.
- */
-import { processConditionals, resolveSkill, } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export async function buildDiagramSystemPrompt(skillRef, contractKey, opts) {
-    const skill = await resolveSkill(skillRef, { projectDir: opts?.projectDir });
-    if (!skill) {
-        throw new Error(`Failed to load skill: ${skillRef}`);
-    }
-    const prompt = processConditionals(skill.prompt, {
-        hasCodebase: opts?.hasCodebase ?? true,
-    });
-    return `${prompt}
-
-${OUTPUT_CONTRACTS[contractKey]}`;
-}
-export function buildDiagramUserPrompt(args) {
-    const descBlock = args.productDescription
-        ? `\n**Product description**: ${args.productDescription}`
-        : '';
-    const guidanceBlock = args.guidance
-        ? `\n\n**Human guidance for this run** (focus or exclude as instructed):\n${args.guidance}`
-        : '';
-    return `${args.task} **${args.productName}**.${descBlock}${guidanceBlock}
-
-${args.process}
-
-Call \`mcp__${args.mcpName}__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__${args.mcpName}__submit_${args.toolName}\` tool exactly once**. 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/discover-services/index.d.ts

@@ -1,29 +0,0 @@
-/**
- * Phase: discover-services (GitHub Discovery)
- *
- * Scans every repository in a team's connected GitHub organisation and infers
- * a service for each one. The server mints a short-lived org-scoped token
- * (`github/org_token`) and the CLI reads each repo's signal files directly via
- * Octokit — a handful of root files (README, package manifests, Dockerfile) —
- * so private repos are read over the API without cloning. It then derives a
- * service identity (name, language, kind, description) heuristically and
- * upserts it into the team-scoped service catalog (`services` + a `repo`
- * component).
- *
- * Progress is recorded against a `discovery_runs` row: the run is flipped to
- * `running`, heart-beaten on every repo, and finalized as `success`/`failed`.
- * The desktop Discover Services page reads that row to render live status.
- */
-export interface DiscoverServicesResult {
-    status: 'success' | 'error';
-    message: string;
-    reposScanned: number;
-    servicesCreated: number;
-    servicesUpdated: number;
-}
-export declare function discoverServices(opts: {
-    teamId: string;
-    runId?: string;
-    org?: string;
-    verbose?: boolean;
-}): Promise<DiscoverServicesResult>;