@webpresso/agent-kit 0.21.4 → 0.21.5

package/dist/esm/blueprint/graph/schema.js

@@ -1,104 +0,0 @@
-import { z } from 'zod';
-export const graphNodeTypeSchema = z.enum([
-    'task',
-    'milestone',
-    'decision',
-    'external',
-    'tech_debt',
-    'blueprint',
-]);
-export const graphEdgeTypeSchema = z.enum(['depends_on', 'blocks', 'relates_to']);
-export const graphNodeSchema = z.object({
-    id: z.string().min(1),
-    type: graphNodeTypeSchema,
-    label: z.string().min(1),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-});
-export const graphEdgeSchema = z.object({
-    source: z.string().min(1),
-    target: z.string().min(1),
-    type: graphEdgeTypeSchema,
-    label: z.string().optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-});
-export const graphLayoutSchema = z.object({
-    direction: z.enum(['TD', 'LR', 'BT', 'RL']).default('TD'),
-    rankdir: z.string().optional(),
-});
-function hasCycle(edges) {
-    const adjacency = new Map();
-    const visiting = new Set();
-    const visited = new Set();
-    for (const edge of edges) {
-        const targets = adjacency.get(edge.source) ?? [];
-        targets.push(edge.target);
-        adjacency.set(edge.source, targets);
-    }
-    function visit(node) {
-        if (visiting.has(node)) {
-            return true;
-        }
-        if (visited.has(node)) {
-            return false;
-        }
-        visiting.add(node);
-        const targets = adjacency.get(node) ?? [];
-        for (const target of targets) {
-            if (visit(target)) {
-                return true;
-            }
-        }
-        visiting.delete(node);
-        visited.add(node);
-        return false;
-    }
-    for (const node of adjacency.keys()) {
-        if (visit(node)) {
-            return true;
-        }
-    }
-    return false;
-}
-export const normalizedGraphSchema = z
-    .object({
-    nodes: z.array(graphNodeSchema),
-    edges: z.array(graphEdgeSchema),
-    layout: graphLayoutSchema.optional(),
-})
-    .superRefine((graph, context) => {
-    const nodeIds = new Set();
-    for (const [index, node] of graph.nodes.entries()) {
-        if (nodeIds.has(node.id)) {
-            context.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `Duplicate node id: ${node.id}`,
-                path: ['nodes', index, 'id'],
-            });
-        }
-        nodeIds.add(node.id);
-    }
-    for (const [index, edge] of graph.edges.entries()) {
-        if (!nodeIds.has(edge.source)) {
-            context.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `Edge source not found: ${edge.source}`,
-                path: ['edges', index, 'source'],
-            });
-        }
-        if (!nodeIds.has(edge.target)) {
-            context.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `Edge target not found: ${edge.target}`,
-                path: ['edges', index, 'target'],
-            });
-        }
-    }
-    if (hasCycle(graph.edges)) {
-        context.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: 'Graph contains a cycle',
-            path: ['edges'],
-        });
-    }
-});
-//# sourceMappingURL=schema.js.map

package/dist/esm/blueprint/graph/task-graph-adapter.d.ts

@@ -1,6 +0,0 @@
-import type { TaskGraph } from '#dag/task-graph';
-import { type NormalizedGraph } from '#graph/schema';
-export declare function taskGraphToNormalizedGraph(taskGraph: TaskGraph<{
-    title: string;
-}>): NormalizedGraph;
-//# sourceMappingURL=task-graph-adapter.d.ts.map

package/dist/esm/blueprint/graph/task-graph-adapter.js

@@ -1,30 +0,0 @@
-import { normalizedGraphSchema } from '#graph/schema';
-export function taskGraphToNormalizedGraph(taskGraph) {
-    const tasks = taskGraph.getTopologicalOrder();
-    const waves = taskGraph.getWaves();
-    const waveByTaskId = new Map();
-    for (const [waveIndex, wave] of waves.entries()) {
-        for (const task of wave) {
-            waveByTaskId.set(task.id, waveIndex);
-        }
-    }
-    const nodes = tasks.map((task) => ({
-        id: task.id,
-        type: 'task',
-        label: task.data?.title ?? task.id,
-        metadata: {
-            wave_number: waveByTaskId.get(task.id) ?? 0,
-        },
-    }));
-    const edges = tasks.flatMap((task) => task.dependencies.map((dependencyId) => ({
-        source: dependencyId,
-        target: task.id,
-        type: 'depends_on',
-    })));
-    return normalizedGraphSchema.parse({
-        nodes,
-        edges,
-        layout: { direction: 'TD' },
-    });
-}
-//# sourceMappingURL=task-graph-adapter.js.map