edsger 0.69.0 → 0.71.0

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

@@ -0,0 +1,35 @@
+/**
+ * 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

@@ -0,0 +1,68 @@
+/**
+ * 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

@@ -0,0 +1,23 @@
+/**
+ * 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

@@ -0,0 +1,35 @@
+/**
+ * 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

@@ -0,0 +1,29 @@
+/**
+ * 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>;