@synth-deploy/server 0.1.0

package/src/graph/graph-executor.ts

@@ -0,0 +1,446 @@
+import type {
+  DeploymentGraph,
+  DeploymentGraphNode,
+  DeploymentGraphEdge,
+  DeploymentPlan,
+} from "@synth-deploy/core";
+import type { EnvoyRegistry } from "../agent/envoy-registry.js";
+import type { EnvoyClient, EnvoyDeployResult } from "../agent/envoy-client.js";
+
+// ---------------------------------------------------------------------------
+// Progress events emitted during graph execution
+// ---------------------------------------------------------------------------
+
+export interface GraphProgressEvent {
+  type:
+    | "node-started"
+    | "node-completed"
+    | "node-failed"
+    | "node-skipped"
+    | "graph-completed"
+    | "graph-failed";
+  nodeId?: string;
+  graphId: string;
+  progress: {
+    completed: number;
+    total: number;
+    executing: number;
+    failed: number;
+  };
+  outputCapture?: Record<string, string>;
+  error?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Topological sort — Kahn's algorithm
+// ---------------------------------------------------------------------------
+
+export function topologicalSort(
+  nodes: DeploymentGraphNode[],
+  edges: DeploymentGraphEdge[],
+): string[] {
+  const inDegree = new Map<string, number>();
+  const adjacency = new Map<string, string[]>();
+
+  for (const node of nodes) {
+    inDegree.set(node.id, 0);
+    adjacency.set(node.id, []);
+  }
+
+  for (const edge of edges) {
+    inDegree.set(edge.to, (inDegree.get(edge.to) ?? 0) + 1);
+    adjacency.get(edge.from)?.push(edge.to);
+  }
+
+  const queue = nodes
+    .filter((n) => (inDegree.get(n.id) ?? 0) === 0)
+    .map((n) => n.id);
+  const result: string[] = [];
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    result.push(current);
+
+    for (const neighbor of adjacency.get(current) ?? []) {
+      const deg = (inDegree.get(neighbor) ?? 1) - 1;
+      inDegree.set(neighbor, deg);
+      if (deg === 0) queue.push(neighbor);
+    }
+  }
+
+  if (result.length !== nodes.length) {
+    throw new Error(
+      "Cycle detected in deployment graph — topological sort is impossible",
+    );
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Depth computation — group nodes by distance from roots for parallel exec
+// ---------------------------------------------------------------------------
+
+export function computeDepths(
+  nodes: DeploymentGraphNode[],
+  edges: DeploymentGraphEdge[],
+): Map<string, number> {
+  const depths = new Map<string, number>();
+  const inEdges = new Map<string, string[]>(); // nodeId -> list of "from" nodeIds
+  for (const node of nodes) {
+    depths.set(node.id, 0);
+    inEdges.set(node.id, []);
+  }
+  for (const edge of edges) {
+    inEdges.get(edge.to)?.push(edge.from);
+  }
+  // BFS to compute max depth
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const node of nodes) {
+      const parents = inEdges.get(node.id) ?? [];
+      const maxParent = Math.max(0, ...parents.map((p) => depths.get(p) ?? 0));
+      const newDepth = parents.length > 0 ? maxParent + 1 : 0;
+      if (newDepth > (depths.get(node.id) ?? 0)) {
+        depths.set(node.id, newDepth);
+        changed = true;
+      }
+    }
+  }
+  return depths;
+}
+
+// ---------------------------------------------------------------------------
+// Downstream node computation — find all transitive dependents of a node
+// ---------------------------------------------------------------------------
+
+function getDownstreamNodeIds(
+  nodeId: string,
+  edges: DeploymentGraphEdge[],
+): Set<string> {
+  const downstream = new Set<string>();
+  const adjacency = new Map<string, string[]>();
+  for (const edge of edges) {
+    if (!adjacency.has(edge.from)) adjacency.set(edge.from, []);
+    adjacency.get(edge.from)!.push(edge.to);
+  }
+
+  const queue = [nodeId];
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    for (const child of adjacency.get(current) ?? []) {
+      if (!downstream.has(child)) {
+        downstream.add(child);
+        queue.push(child);
+      }
+    }
+  }
+  return downstream;
+}
+
+// ---------------------------------------------------------------------------
+// GraphExecutor — depth-based parallel execution
+// ---------------------------------------------------------------------------
+
+export class GraphExecutor {
+  constructor(
+    private envoyRegistry: EnvoyRegistry,
+    private createClient: (url: string, timeoutMs: number) => EnvoyClient,
+  ) {}
+
+  /**
+   * Execute a deployment graph with depth-based parallelism.
+   * Nodes at the same depth run concurrently via Promise.allSettled().
+   * If a node fails, all its downstream dependents are skipped,
+   * but sibling nodes at the same depth continue executing.
+   */
+  async *execute(
+    graph: DeploymentGraph,
+    plans: Map<string, DeploymentPlan>,
+    partitionVariables?: Record<string, string>,
+  ): AsyncGenerator<GraphProgressEvent> {
+    // Validate topological order (detects cycles)
+    topologicalSort(graph.nodes, graph.edges);
+
+    const depths = computeDepths(graph.nodes, graph.edges);
+    const completed = new Map<string, Record<string, string>>();
+    let completedCount = 0;
+    let failedCount = 0;
+    const skippedNodes = new Set<string>();
+
+    // Group nodes by depth
+    const maxDepth = Math.max(0, ...Array.from(depths.values()));
+    const depthGroups: DeploymentGraphNode[][] = [];
+    for (let d = 0; d <= maxDepth; d++) {
+      depthGroups.push(
+        graph.nodes.filter((n) => (depths.get(n.id) ?? 0) === d),
+      );
+    }
+
+    for (const group of depthGroups) {
+      // Filter out nodes that should be skipped (downstream of failed nodes)
+      const executableNodes = group.filter((n) => !skippedNodes.has(n.id));
+
+      if (executableNodes.length === 0) continue;
+
+      // Collect events from parallel execution, then yield them after
+      const levelEvents: GraphProgressEvent[] = [];
+      const executingCount = executableNodes.length;
+
+      // Execute all nodes at this depth concurrently
+      const results = await Promise.allSettled(
+        executableNodes.map(async (node) => {
+          // Resolve input bindings from completed upstream outputs
+          const resolvedVars: Record<string, string> = {};
+
+          // Merge partition variables first (input bindings override)
+          if (partitionVariables) {
+            Object.assign(resolvedVars, partitionVariables);
+          }
+
+          for (const binding of node.inputBindings ?? []) {
+            const upstreamOutputs = completed.get(binding.sourceNodeId);
+            if (upstreamOutputs?.[binding.sourceOutputName]) {
+              resolvedVars[binding.variable] =
+                upstreamOutputs[binding.sourceOutputName];
+              binding.resolvedValue =
+                upstreamOutputs[binding.sourceOutputName];
+            }
+          }
+
+          levelEvents.push({
+            type: "node-started",
+            nodeId: node.id,
+            graphId: graph.id,
+            progress: {
+              completed: completedCount,
+              total: graph.nodes.length,
+              executing: executingCount,
+              failed: failedCount,
+            },
+          });
+
+          const entry = this.envoyRegistry.get(node.envoyId);
+          if (!entry) {
+            throw new Error(`Envoy not found: ${node.envoyId}`);
+          }
+
+          const plan = plans.get(node.id);
+          if (!plan) {
+            throw new Error(`No plan found for node: ${node.id}`);
+          }
+
+          const client = this.createClient(entry.url, 60_000);
+
+          // Inject resolved variables into the plan's reasoning for traceability
+          const enrichedPlan: DeploymentPlan =
+            Object.keys(resolvedVars).length > 0
+              ? {
+                  ...plan,
+                  reasoning: `${plan.reasoning}\n\nResolved variables from upstream: ${JSON.stringify(resolvedVars)}`,
+                }
+              : plan;
+
+          const result: EnvoyDeployResult = await client.executeApprovedPlan({
+            deploymentId: node.deploymentId ?? node.id,
+            plan: enrichedPlan,
+            rollbackPlan: {
+              steps: [],
+              reasoning: "No rollback plan provided",
+            },
+            artifactType: "graph-node",
+            artifactName: node.artifactId,
+            environmentId: "",
+          });
+
+          // Capture outputs from step results
+          const outputs: Record<string, string> = {};
+          for (const binding of node.outputBindings ?? []) {
+            if (
+              binding.source === "plan_step_output" &&
+              binding.stepIndex != null &&
+              binding.outputKey
+            ) {
+              const stepResult = result.debriefEntries?.[binding.stepIndex];
+              if (stepResult) {
+                outputs[binding.name] = String(
+                  (stepResult.context as Record<string, unknown>)?.[
+                    binding.outputKey
+                  ] ?? "",
+                );
+              }
+            } else if (binding.source === "manual" && binding.value) {
+              outputs[binding.name] = binding.value;
+            }
+          }
+
+          return { nodeId: node.id, outputs };
+        }),
+      );
+
+      // Process results: update state and collect events
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const node = executableNodes[i];
+
+        if (result.status === "fulfilled") {
+          completed.set(result.value.nodeId, result.value.outputs);
+          completedCount++;
+
+          levelEvents.push({
+            type: "node-completed",
+            nodeId: node.id,
+            graphId: graph.id,
+            outputCapture: result.value.outputs,
+            progress: {
+              completed: completedCount,
+              total: graph.nodes.length,
+              executing: 0,
+              failed: failedCount,
+            },
+          });
+        } else {
+          failedCount++;
+          const message =
+            result.reason instanceof Error
+              ? result.reason.message
+              : String(result.reason);
+
+          levelEvents.push({
+            type: "node-failed",
+            nodeId: node.id,
+            graphId: graph.id,
+            error: message,
+            progress: {
+              completed: completedCount,
+              total: graph.nodes.length,
+              executing: 0,
+              failed: failedCount,
+            },
+          });
+
+          // Mark all downstream nodes as skipped
+          const downstream = getDownstreamNodeIds(node.id, graph.edges);
+          for (const downId of downstream) {
+            skippedNodes.add(downId);
+          }
+        }
+      }
+
+      // Yield all events from this depth level
+      for (const event of levelEvents) {
+        yield event;
+      }
+
+      // Yield skipped events for nodes in future depth levels that were just marked
+      for (const node of graph.nodes) {
+        if (skippedNodes.has(node.id) && !completed.has(node.id)) {
+          // Only yield skipped event once — remove from set tracking after yield
+          // We'll check depth to avoid yielding for nodes not yet reached
+          const nodeDepth = depths.get(node.id) ?? 0;
+          const currentDepth = depths.get(group[0].id) ?? 0;
+          if (nodeDepth === currentDepth + 1) {
+            // Don't yield yet — will be handled when we reach that depth level
+          }
+        }
+      }
+    }
+
+    // Yield skip events for any remaining skipped nodes
+    for (const nodeId of skippedNodes) {
+      if (!completed.has(nodeId)) {
+        yield {
+          type: "node-skipped",
+          nodeId,
+          graphId: graph.id,
+          error: "Skipped due to upstream failure",
+          progress: {
+            completed: completedCount,
+            total: graph.nodes.length,
+            executing: 0,
+            failed: failedCount,
+          },
+        };
+      }
+    }
+
+    if (failedCount === 0) {
+      yield {
+        type: "graph-completed",
+        graphId: graph.id,
+        progress: {
+          completed: completedCount,
+          total: graph.nodes.length,
+          executing: 0,
+          failed: 0,
+        },
+      };
+    } else {
+      yield {
+        type: "graph-failed",
+        graphId: graph.id,
+        progress: {
+          completed: completedCount,
+          total: graph.nodes.length,
+          executing: 0,
+          failed: failedCount,
+        },
+      };
+    }
+  }
+
+  /**
+   * Rollback completed nodes in reverse topological order.
+   * Only rolls back nodes that completed successfully.
+   */
+  async *rollback(
+    graph: DeploymentGraph,
+    rollbackPlans: Map<string, DeploymentPlan>,
+  ): AsyncGenerator<GraphProgressEvent> {
+    const sorted = topologicalSort(graph.nodes, graph.edges).reverse();
+    let rolledBack = 0;
+    let rollbackFailed = 0;
+
+    for (const nodeId of sorted) {
+      const node = graph.nodes.find((n) => n.id === nodeId)!;
+      if (node.status !== "completed") continue;
+
+      const plan = rollbackPlans.get(nodeId);
+      if (!plan) continue;
+
+      const entry = this.envoyRegistry.get(node.envoyId);
+      if (!entry) continue;
+
+      const client = this.createClient(entry.url, 60_000);
+
+      try {
+        await client.executeApprovedPlan({
+          deploymentId: node.deploymentId ?? nodeId,
+          plan,
+          rollbackPlan: {
+            steps: [],
+            reasoning: "Rollback of rollback not supported",
+          },
+          artifactType: "graph-node-rollback",
+          artifactName: node.artifactId,
+          environmentId: "",
+        });
+        rolledBack++;
+      } catch {
+        rollbackFailed++;
+      }
+    }
+
+    yield {
+      type: rollbackFailed === 0 ? "graph-completed" : "graph-failed",
+      graphId: graph.id,
+      progress: {
+        completed: rolledBack,
+        total: graph.nodes.filter((n) => n.status === "completed").length,
+        executing: 0,
+        failed: rollbackFailed,
+      },
+    };
+  }
+}

package/src/graph/graph-inference.ts

@@ -0,0 +1,184 @@
+import crypto from "node:crypto";
+import { z } from "zod";
+import type {
+  DeploymentGraph,
+  DeploymentGraphNode,
+  DeploymentGraphEdge,
+} from "@synth-deploy/core";
+import type { LlmClient, LlmResult, IArtifactStore } from "@synth-deploy/core";
+import { sanitizeForPrompt } from "@synth-deploy/core";
+
+// ---------------------------------------------------------------------------
+// Zod schema for LLM graph inference response validation
+// ---------------------------------------------------------------------------
+
+const InferredEdgeSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  type: z.enum(["depends_on", "data_flow"]),
+  dataBinding: z.object({
+    outputName: z.string(),
+    inputVariable: z.string(),
+  }).optional(),
+});
+
+const GraphInferenceResponseSchema = z.object({
+  edges: z.array(InferredEdgeSchema),
+  reasoning: z.string().optional(),
+});
+
+// ---------------------------------------------------------------------------
+// GraphInferenceEngine — uses LLM to reason about deployment ordering
+// ---------------------------------------------------------------------------
+
+interface InferGraphParams {
+  artifactIds: string[];
+  envoyAssignments: Record<string, string>; // artifactId -> envoyId
+  partitionId?: string;
+  graphName?: string;
+}
+
+const GRAPH_INFERENCE_SYSTEM_PROMPT = `You are a deployment orchestration expert. Given a set of deployment artifacts with their analyses, determine the correct execution order and any data flow between them.
+
+Your response must be valid JSON with this structure:
+{
+  "edges": [
+    {
+      "from": "<artifactId that must deploy FIRST>",
+      "to": "<artifactId that depends on it>",
+      "type": "depends_on" | "data_flow",
+      "dataBinding": { "outputName": "<name>", "inputVariable": "<var>" }  // only for data_flow edges
+    }
+  ],
+  "reasoning": "Plain-language explanation of why this ordering was chosen."
+}
+
+Rules:
+- "from" deploys BEFORE "to"
+- Only add edges where there is a genuine dependency (shared database, API dependency, config requirement)
+- Use "data_flow" when one artifact produces a value (e.g., a URL, port, hostname) that another needs
+- Use "depends_on" for ordering-only dependencies (e.g., database must be up before the app)
+- Do not create cycles
+- If artifacts are independent, return an empty edges array`;
+
+export class GraphInferenceEngine {
+  constructor(
+    private llm: LlmClient,
+    private artifactStore: IArtifactStore,
+  ) {}
+
+  /**
+   * Infer a deployment graph from a set of artifacts and their envoy assignments.
+   * Uses the LLM to reason about ordering and data flow when available.
+   * Falls back to a flat graph (all parallel) when LLM is unavailable.
+   */
+  async inferGraph(params: InferGraphParams): Promise<DeploymentGraph> {
+    const { artifactIds, envoyAssignments, partitionId, graphName } = params;
+    const now = new Date();
+
+    // Build nodes from artifact/envoy assignments
+    const nodes: DeploymentGraphNode[] = artifactIds.map((artifactId) => ({
+      id: crypto.randomUUID(),
+      artifactId,
+      envoyId: envoyAssignments[artifactId] ?? "",
+      outputBindings: [],
+      inputBindings: [],
+      status: "pending" as const,
+    }));
+
+    // Map from artifactId to nodeId for edge resolution
+    const artifactToNodeId = new Map<string, string>();
+    for (const node of nodes) {
+      artifactToNodeId.set(node.artifactId, node.id);
+    }
+
+    let edges: DeploymentGraphEdge[] = [];
+
+    // Attempt LLM inference
+    if (this.llm.isAvailable() && artifactIds.length > 1) {
+      edges = await this._inferEdgesWithLlm(artifactIds, artifactToNodeId);
+    }
+
+    return {
+      id: crypto.randomUUID(),
+      name: graphName ?? `Graph ${now.toISOString().slice(0, 19)}`,
+      partitionId,
+      nodes,
+      edges,
+      status: "draft",
+      approvalMode: "graph",
+      createdAt: now,
+      updatedAt: now,
+    };
+  }
+
+  private async _inferEdgesWithLlm(
+    artifactIds: string[],
+    artifactToNodeId: Map<string, string>,
+  ): Promise<DeploymentGraphEdge[]> {
+    // Build context from artifact analyses
+    const artifactContext: string[] = [];
+    for (const artifactId of artifactIds) {
+      const artifact = this.artifactStore.get(artifactId);
+      if (!artifact) {
+        artifactContext.push(`- ${artifactId}: (artifact not found)`);
+        continue;
+      }
+
+      artifactContext.push(
+        `- ID: ${artifactId}\n` +
+        `  Name: ${sanitizeForPrompt(artifact.name)}\n` +
+        `  Type: ${sanitizeForPrompt(artifact.type)}\n` +
+        `  Summary: ${sanitizeForPrompt(artifact.analysis.summary)}\n` +
+        `  Dependencies: ${sanitizeForPrompt(JSON.stringify(artifact.analysis.dependencies))}\n` +
+        `  Config expectations: ${sanitizeForPrompt(JSON.stringify(artifact.analysis.configurationExpectations))}\n` +
+        `  Deployment intent: ${sanitizeForPrompt(artifact.analysis.deploymentIntent ?? "unknown")}`,
+      );
+    }
+
+    const prompt = `Determine the deployment ordering for these artifacts:\n\n${artifactContext.join("\n\n")}\n\nArtifact IDs to use in edges: ${JSON.stringify(artifactIds)}`;
+
+    let result: LlmResult;
+    try {
+      result = await this.llm.reason({
+        prompt,
+        systemPrompt: GRAPH_INFERENCE_SYSTEM_PROMPT,
+        promptSummary: `Graph inference for ${artifactIds.length} artifacts`,
+      });
+    } catch {
+      return [];
+    }
+
+    if (!result.ok) return [];
+
+    try {
+      const jsonMatch = result.text.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) return [];
+
+      const raw = JSON.parse(jsonMatch[0]);
+      const parseResult = GraphInferenceResponseSchema.safeParse(raw);
+      if (!parseResult.success) return [];
+
+      const parsed = parseResult.data;
+
+      // Convert artifact-level edges to node-level edges
+      const graphEdges: DeploymentGraphEdge[] = [];
+      for (const edge of parsed.edges) {
+        const fromNodeId = artifactToNodeId.get(edge.from);
+        const toNodeId = artifactToNodeId.get(edge.to);
+        if (!fromNodeId || !toNodeId) continue;
+
+        graphEdges.push({
+          from: fromNodeId,
+          to: toNodeId,
+          type: edge.type === "data_flow" ? "data_flow" : "depends_on",
+          dataBinding: edge.dataBinding,
+        });
+      }
+
+      return graphEdges;
+    } catch {
+      return [];
+    }
+  }
+}

package/src/graph/graph-store.ts

@@ -0,0 +1,75 @@
+import type {
+  DeploymentGraph,
+  DeploymentGraphStatus,
+  DeploymentGraphNode,
+} from "@synth-deploy/core";
+
+// ---------------------------------------------------------------------------
+// DeploymentGraphStore — in-memory store for deployment graphs
+// ---------------------------------------------------------------------------
+
+export class DeploymentGraphStore {
+  private graphs = new Map<string, DeploymentGraph>();
+
+  create(graph: DeploymentGraph): DeploymentGraph {
+    this.graphs.set(graph.id, graph);
+    return graph;
+  }
+
+  getById(id: string): DeploymentGraph | undefined {
+    return this.graphs.get(id);
+  }
+
+  update(
+    id: string,
+    updates: Partial<Pick<DeploymentGraph, "name" | "nodes" | "edges" | "status" | "approvalMode" | "partitionId">>,
+  ): DeploymentGraph | undefined {
+    const existing = this.graphs.get(id);
+    if (!existing) return undefined;
+
+    if (updates.name !== undefined) existing.name = updates.name;
+    if (updates.nodes !== undefined) existing.nodes = updates.nodes;
+    if (updates.edges !== undefined) existing.edges = updates.edges;
+    if (updates.status !== undefined) existing.status = updates.status;
+    if (updates.approvalMode !== undefined) existing.approvalMode = updates.approvalMode;
+    if (updates.partitionId !== undefined) existing.partitionId = updates.partitionId;
+    existing.updatedAt = new Date();
+
+    return existing;
+  }
+
+  updateStatus(id: string, status: DeploymentGraphStatus): DeploymentGraph | undefined {
+    const existing = this.graphs.get(id);
+    if (!existing) return undefined;
+
+    existing.status = status;
+    existing.updatedAt = new Date();
+    return existing;
+  }
+
+  updateNode(
+    graphId: string,
+    nodeId: string,
+    updates: Partial<Pick<DeploymentGraphNode, "status" | "deploymentId">>,
+  ): DeploymentGraphNode | undefined {
+    const graph = this.graphs.get(graphId);
+    if (!graph) return undefined;
+
+    const node = graph.nodes.find((n) => n.id === nodeId);
+    if (!node) return undefined;
+
+    if (updates.status !== undefined) node.status = updates.status;
+    if (updates.deploymentId !== undefined) node.deploymentId = updates.deploymentId;
+    graph.updatedAt = new Date();
+
+    return node;
+  }
+
+  list(): DeploymentGraph[] {
+    return Array.from(this.graphs.values());
+  }
+
+  delete(id: string): boolean {
+    return this.graphs.delete(id);
+  }
+}

package/src/graph/index.ts

@@ -0,0 +1,4 @@
+export { GraphExecutor, topologicalSort } from "./graph-executor.js";
+export type { GraphProgressEvent } from "./graph-executor.js";
+export { GraphInferenceEngine } from "./graph-inference.js";
+export { DeploymentGraphStore } from "./graph-store.js";