@ghchinoy/litflow 0.2.7 → 0.3.0

package/src/breadboard/engine/editor/operations/add-graph.ts

@@ -0,0 +1,47 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+
+export { AddGraph };
+
+class AddGraph implements EditOperation {
+  async do(
+    edit: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (edit.type !== "addgraph") {
+      throw new Error(
+        `Editor API integrity error: expected type "addgraph", received "${edit.type}" instead.`
+      );
+    }
+    const { id, graph: subgraph } = edit;
+    const { graph, mutable } = context;
+
+    if (graph.graphs?.[id]) {
+      return {
+        success: false,
+        error: `Failed to add graph: "${id}" already exists.`,
+      };
+    }
+    graph.graphs ??= {};
+    graph.graphs[id] = subgraph;
+    mutable.addSubgraph(subgraph, id);
+
+    return {
+      success: true,
+      affectedModules: [],
+      affectedNodes: [],
+      affectedGraphs: [id],
+    };
+  }
+}

package/src/breadboard/engine/editor/operations/add-module.ts

@@ -0,0 +1,64 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  InspectableGraph,
+  ModuleIdentifier,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+
+export class AddModule implements EditOperation {
+  async can(
+    id: ModuleIdentifier,
+    inspector: InspectableGraph
+  ): Promise<SingleEditResult> {
+    const exists = inspector.moduleById(id);
+    if (exists) {
+      return {
+        success: false,
+        error: `Unable to add module: module with id "${id}" already exists`,
+      };
+    }
+    return {
+      success: true,
+      affectedNodes: [],
+      affectedModules: [id],
+      affectedGraphs: [],
+    };
+  }
+
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "addmodule") {
+      throw new Error(
+        `Editor API integrity error: expected type "addmodule", received "${spec.type}" instead.`
+      );
+    }
+    const { id, module } = spec;
+    const { graph, mutable } = context;
+    const inspector = mutable.graphs.get("")!;
+    const can = await this.can(id, inspector);
+    if (!can.success) {
+      return can;
+    }
+
+    graph.modules ??= {};
+    graph.modules[id] = module;
+
+    return {
+      success: true,
+      affectedNodes: [],
+      affectedModules: [id],
+      affectedGraphs: [],
+    };
+  }
+}

package/src/breadboard/engine/editor/operations/add-node.ts

@@ -0,0 +1,86 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  EditableNodeSpec,
+  InspectableGraph,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+import { GraphDescriptorHandle } from "../../inspector/graph/graph-descriptor-handle.js";
+import { errorNoInspect } from "./error.js";
+
+export class AddNode implements EditOperation {
+  async can(
+    spec: EditableNodeSpec,
+    inspector: InspectableGraph
+  ): Promise<SingleEditResult> {
+    const duplicate = !!inspector.nodeById(spec.id);
+    if (duplicate) {
+      return {
+        success: false,
+        error: `Unable to add node: a node with id "${spec.id}" already exists`,
+      };
+    }
+
+    const validType = !!inspector.typeById(spec.type);
+    if (!validType) {
+      return {
+        success: false,
+        error: `Unable to add node: node type "${spec.type}" is not a known type`,
+      };
+    }
+
+    return {
+      success: true,
+      affectedNodes: [],
+      affectedModules: [],
+      affectedGraphs: [],
+      topologyChange: true,
+    };
+  }
+
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "addnode") {
+      throw new Error(
+        `Editor API integrity error: expected type "addnode", received "${spec.type}" instead.`
+      );
+    }
+    const { node, graphId } = spec;
+
+    const { graph, mutable } = context;
+    const inspector = mutable.graphs.get(graphId);
+    if (!inspector) {
+      return errorNoInspect(graphId);
+    }
+
+    const handle = GraphDescriptorHandle.create(graph, graphId);
+    if (!handle.success) {
+      return handle;
+    }
+
+    const can = await this.can(node, inspector);
+    if (!can.success) {
+      return can;
+    }
+
+    handle.result.graph().nodes.push(node);
+    mutable.nodes.add(node, graphId);
+    return {
+      success: true,
+      affectedNodes: [{ id: node.id, graphId }],
+      affectedModules: [],
+      affectedGraphs: [graphId],
+      topologyChange: true,
+    };
+  }
+}

package/src/breadboard/engine/editor/operations/change-asset-metadata.ts

@@ -0,0 +1,70 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  AssetMetadata,
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+
+export { ChangeAssetMetadata };
+
+class ChangeAssetMetadata implements EditOperation {
+  #isVisualOnly(
+    incoming: AssetMetadata,
+    existing: AssetMetadata | undefined
+  ): boolean {
+    if (!existing) {
+      return false;
+    }
+    return (
+      existing.title === incoming.title &&
+      existing.description === incoming.description &&
+      existing.type === incoming.type &&
+      existing.subType == incoming.subType &&
+      existing.managed === incoming.managed
+    );
+  }
+
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "changeassetmetadata") {
+      throw new Error(
+        `Editor API integrity error: expected type "changeassetmetadata", received "${spec.type}" instead.`
+      );
+    }
+
+    const { path, metadata } = spec;
+
+    const { graph } = context;
+
+    const asset = graph.assets?.[path];
+
+    if (!asset) {
+      return {
+        success: false,
+        error: `Unable to edit non-existing asset "${path}"`,
+      };
+    }
+
+    const visualOnly = this.#isVisualOnly(metadata, asset.metadata);
+
+    asset.metadata = metadata;
+
+    return {
+      visualOnly,
+      success: true,
+      affectedGraphs: [],
+      affectedModules: [],
+      affectedNodes: [],
+    };
+  }
+}

package/src/breadboard/engine/editor/operations/change-configuration.ts

@@ -0,0 +1,82 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  InspectableGraph,
+  NodeIdentifier,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+import { errorNoInspect } from "./error.js";
+
+export class ChangeConfiguration implements EditOperation {
+  async can(
+    id: NodeIdentifier,
+    inspector: InspectableGraph
+  ): Promise<SingleEditResult> {
+    const node = inspector.nodeById(id);
+    if (!node) {
+      return {
+        success: false,
+        error: `Unable to update configuration: node with id "${id}" does not exist`,
+      };
+    }
+    return {
+      success: true,
+      affectedNodes: [],
+      affectedModules: [],
+      affectedGraphs: [],
+    };
+  }
+
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "changeconfiguration") {
+      throw new Error(
+        `Editor API integrity error: expected type "changeconfiguration", received "${spec.type}" instead.`
+      );
+    }
+    const { id, configuration, graphId, reset = false } = spec;
+    if (!configuration) {
+      return {
+        success: false,
+        error: "Configuration wasn't supplied.",
+      };
+    }
+    const { mutable } = context;
+    const inspector = mutable.graphs.get(graphId);
+    if (!inspector) {
+      return errorNoInspect(graphId);
+    }
+
+    const can = await this.can(id, inspector);
+    if (!can.success) {
+      return can;
+    }
+    const node = inspector.nodeById(id);
+    if (node) {
+      if (reset) {
+        node.descriptor.configuration = configuration;
+      } else {
+        node.descriptor.configuration = {
+          ...node.descriptor.configuration,
+          ...configuration,
+        };
+      }
+    }
+    return {
+      success: true,
+      affectedNodes: [{ id, graphId }],
+      affectedModules: [],
+      affectedGraphs: [graphId],
+    };
+  }
+}

package/src/breadboard/engine/editor/operations/change-edge-metadata.ts

@@ -0,0 +1,58 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+import { GraphDescriptorHandle } from "../../inspector/graph/graph-descriptor-handle.js";
+import { findEdgeIndex } from "../edge.js";
+import { error } from "./error.js";
+
+export { ChangeEdgeMetadata };
+
+class ChangeEdgeMetadata implements EditOperation {
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "changeedgemetadata") {
+      return error(
+        `Invalid edit operation: expected "changeedgemetadata", got "${spec.type}".`
+      );
+    }
+    const { graphId, metadata, edge } = spec;
+    const { graph: mainGraph } = context;
+
+    const handle = GraphDescriptorHandle.create(mainGraph, graphId);
+    if (!handle.success) {
+      return handle;
+    }
+
+    const graph = handle.result.graph();
+    const index = findEdgeIndex(graph, edge);
+    if (index < 0) {
+      return error(
+        `Unable to find edge between "${edge.from}" and "${edge.to}`
+      );
+    }
+    const existingEdge = graph.edges[index]!;
+    const existingMetadata = existingEdge.metadata || {};
+    existingEdge.metadata = {
+      ...existingMetadata,
+      ...metadata,
+    };
+    return {
+      success: true,
+      affectedGraphs: [graphId],
+      affectedNodes: [],
+      affectedModules: [],
+    };
+  }
+}

package/src/breadboard/engine/editor/operations/change-edge.ts

@@ -0,0 +1,111 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  EditableEdgeSpec,
+  GraphIdentifier,
+  InspectableGraph,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+import { fixUpStarEdge } from "../../inspector/graph/edge.js";
+import { GraphDescriptorHandle } from "../../inspector/graph/graph-descriptor-handle.js";
+import { edgesEqual, findEdgeIndex } from "../edge.js";
+import { AddEdge } from "./add-edge.js";
+import { errorNoInspect } from "./error.js";
+import { RemoveEdge } from "./remove-edge.js";
+
+export class ChangeEdge implements EditOperation {
+  async can(
+    from: EditableEdgeSpec,
+    to: EditableEdgeSpec,
+    inspector: InspectableGraph,
+    graphId: GraphIdentifier
+  ): Promise<SingleEditResult> {
+    if (edgesEqual(from, to)) {
+      return {
+        success: true,
+        affectedNodes: [],
+        affectedModules: [],
+        affectedGraphs: [graphId],
+      };
+    }
+    const canRemoveOp = new RemoveEdge();
+    const canRemove = await canRemoveOp.can(from, inspector, graphId);
+    if (!canRemove.success) return canRemove;
+    const canAddOp = new AddEdge();
+    const canAdd = await canAddOp.can(to, inspector, graphId);
+    if (!canAdd.success) return canAdd;
+    return {
+      success: true,
+      affectedNodes: [],
+      affectedModules: [],
+      affectedGraphs: [graphId],
+    };
+  }
+
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "changeedge") {
+      throw new Error(
+        `Editor API integrity error: expected type "changeedge", received "${spec.type}" instead.`
+      );
+    }
+    const { from, to, graphId } = spec;
+    const { mutable } = context;
+    const inspector = mutable.graphs.get(graphId);
+    if (!inspector) {
+      return errorNoInspect(graphId);
+    }
+
+    const can = await this.can(from, to, inspector, graphId);
+    if (!can.success) {
+      return can;
+    }
+    if (edgesEqual(from, to)) {
+      return {
+        success: true,
+        noChange: true,
+        affectedNodes: [],
+        affectedModules: [],
+        affectedGraphs: [],
+        topologyChange: true,
+      };
+    }
+    const handle = GraphDescriptorHandle.create(context.graph, graphId);
+    if (!handle.success) {
+      return handle;
+    }
+    const graph = handle.result.graph();
+
+    const fixedUpEdge = fixUpStarEdge(from);
+    const edges = graph.edges;
+    const index = findEdgeIndex(graph, fixedUpEdge);
+    const edge = edges[index];
+    edge.from = to.from;
+    edge.out = to.out;
+    edge.to = to.to;
+    edge.in = to.in;
+    if (to.constant === true) {
+      edge.constant = to.constant;
+    }
+    return {
+      success: true,
+      affectedNodes: [
+        { id: edge.from, graphId },
+        { id: edge.to, graphId },
+      ],
+      affectedModules: [],
+      affectedGraphs: [graphId],
+      topologyChange: true,
+    };
+  }
+}

package/src/breadboard/engine/editor/operations/change-graph-metadata.ts

@@ -0,0 +1,52 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+import { GraphDescriptorHandle } from "../../inspector/graph/graph-descriptor-handle.js";
+
+export class ChangeGraphMetadata implements EditOperation {
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "changegraphmetadata") {
+      throw new Error(
+        `Editor API integrity error: expected type "changegraphmetadata", received "${spec.type}" instead.`
+      );
+    }
+    const { metadata, graphId, title, description } = spec;
+
+    const handle = GraphDescriptorHandle.create(context.graph, graphId);
+    if (!handle.success) {
+      return handle;
+    }
+    const graph = handle.result.graph();
+
+    const visualOnly = graph.metadata === metadata && !(title || description);
+    if (metadata) {
+      graph.metadata = metadata;
+    }
+    if (title) {
+      graph.title = title;
+    }
+    if (description) {
+      graph.description = description;
+    }
+    return {
+      success: true,
+      visualOnly,
+      affectedNodes: [],
+      affectedModules: [],
+      affectedGraphs: [graphId],
+    };
+  }
+}

package/src/breadboard/engine/editor/operations/change-metadata.ts

@@ -0,0 +1,92 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  InspectableGraph,
+  NodeIdentifier,
+  NodeMetadata,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+import { errorNoInspect } from "./error.js";
+
+export class ChangeMetadata implements EditOperation {
+  async can(
+    id: NodeIdentifier,
+    inspector: InspectableGraph
+  ): Promise<SingleEditResult> {
+    const node = inspector.nodeById(id);
+    if (!node) {
+      return {
+        success: false,
+        error: `Unable to change metadata: node with id "${id}" does not exist`,
+      };
+    }
+    return {
+      success: true,
+      affectedNodes: [],
+      affectedModules: [],
+      affectedGraphs: [],
+    };
+  }
+
+  #isVisualOnly(incoming: NodeMetadata, existing: NodeMetadata): boolean {
+    return (
+      existing.title === incoming.title &&
+      existing.description === incoming.description &&
+      existing.logLevel === incoming.logLevel
+    );
+  }
+
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "changemetadata") {
+      throw new Error(
+        `Editor API integrity error: expected type "changemetadata", received "${spec.type}" instead.`
+      );
+    }
+    const { id, metadata, graphId, reset = false } = spec;
+    const { mutable } = context;
+    const inspector = mutable.graphs.get(graphId);
+    if (!inspector) {
+      return errorNoInspect(graphId);
+    }
+
+    const can = await this.can(id, inspector);
+    if (!can.success) return can;
+    const node = inspector.nodeById(id);
+    if (!node) {
+      const error = `Unknown node with id "${id}"`;
+      return { success: false, error };
+    }
+    const visualOnly = this.#isVisualOnly(
+      metadata,
+      node.descriptor.metadata || {}
+    );
+    const oldMetadata = node.descriptor.metadata;
+    if (reset) {
+      node.descriptor.metadata = metadata;
+    } else {
+      node.descriptor.metadata = {
+        ...oldMetadata,
+        ...metadata,
+      };
+    }
+    const affectedNodes = visualOnly ? [] : [{ id, graphId }];
+    return {
+      success: true,
+      visualOnly,
+      affectedNodes,
+      affectedModules: [],
+      affectedGraphs: [graphId],
+    };
+  }
+}