@ghchinoy/litflow 0.2.8 → 0.4.0

package/src/breadboard/engine/editor/operations/change-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 ChangeModule implements EditOperation {
+  async can(
+    id: ModuleIdentifier,
+    inspector: InspectableGraph
+  ): Promise<SingleEditResult> {
+    const exists = !!inspector.moduleById(id);
+    if (!exists) {
+      return {
+        success: false,
+        error: `Unable to update module: module with id "${id}" does not exist`,
+      };
+    }
+    return {
+      success: true,
+      affectedNodes: [],
+      affectedModules: [id],
+      affectedGraphs: [],
+    };
+  }
+
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "changemodule") {
+      throw new Error(
+        `Editor API integrity error: expected type "changemodule", received "${spec.type}" instead.`
+      );
+    }
+    const id = spec.id;
+    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 || {};
+    graph.modules[spec.id] = spec.module;
+    return {
+      success: true,
+      affectedNodes: [],
+      affectedModules: [spec.id],
+      affectedGraphs: [],
+      visualOnly: false,
+    };
+  }
+}

package/src/breadboard/engine/editor/operations/error.ts

@@ -0,0 +1,21 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { GraphIdentifier, SingleEditResult } from "@breadboard-ai/types";
+
+export { error, errorNoInspect };
+
+function errorNoInspect(graphId: GraphIdentifier) {
+  return error(`Unable to inspect graph with the id of "${graphId}"`);
+}
+
+function error(message: string): SingleEditResult {
+  return {
+    success: false,
+    error: message,
+  };
+}

package/src/breadboard/engine/editor/operations/remove-asset.ts

@@ -0,0 +1,48 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+
+export { RemoveAsset };
+
+class RemoveAsset implements EditOperation {
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "removeasset") {
+      throw new Error(
+        `Editor API integrity error: expected type "removeasset", received "${spec.type}" instead.`
+      );
+    }
+
+    const { path } = spec;
+
+    const {
+      graph: { assets },
+    } = context;
+
+    if (assets) {
+      delete assets[path];
+      if (Object.keys(assets).length === 0) {
+        delete context.graph.assets;
+      }
+    }
+
+    return {
+      success: true,
+      affectedGraphs: [],
+      affectedModules: [],
+      affectedNodes: [],
+    };
+  }
+}

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

@@ -0,0 +1,89 @@
+// @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 { findEdgeIndex } from "../edge.js";
+import { errorNoInspect } from "./error.js";
+
+export class RemoveEdge implements EditOperation {
+  async can(
+    spec: EditableEdgeSpec,
+    inspector: InspectableGraph,
+    graphId: GraphIdentifier
+  ): Promise<SingleEditResult> {
+    if (!inspector.hasEdge(spec)) {
+      return {
+        success: false,
+        error: `Edge from "${spec.from}:${spec.out}" to "${spec.to}:${spec.in}" does not exist`,
+      };
+    }
+    return {
+      success: true,
+      affectedNodes: [
+        { id: spec.from, graphId },
+        { id: spec.to, graphId },
+      ],
+      affectedModules: [],
+      affectedGraphs: [],
+      topologyChange: true,
+    };
+  }
+
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "removeedge") {
+      throw new Error(
+        `Editor API integrity error: expected type "removeedge", received "${spec.type}" instead.`
+      );
+    }
+    let edge = spec.edge;
+    const { graphId } = spec;
+    const { mutable } = context;
+    const inspector = mutable.graphs.get(graphId);
+    if (!inspector) {
+      return errorNoInspect(graphId);
+    }
+
+    const can = await this.can(edge, inspector, graphId);
+    if (!can.success) {
+      return can;
+    }
+    const handle = GraphDescriptorHandle.create(context.graph, graphId);
+    if (!handle.success) {
+      return handle;
+    }
+    const graph = handle.result.graph();
+
+    edge = fixUpStarEdge(edge);
+    const edges = graph.edges;
+    const index = findEdgeIndex(graph, edge);
+    const foundEdge = edges.splice(index, 1)[0];
+    mutable.edges.remove(foundEdge, graphId);
+    return {
+      success: true,
+      affectedNodes: [
+        { id: edge.from, graphId },
+        { id: edge.to, graphId },
+      ],
+      affectedModules: [],
+      affectedGraphs: [graphId],
+      topologyChange: true,
+    };
+  }
+}

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

@@ -0,0 +1,49 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+
+export { RemoveGraph };
+
+class RemoveGraph implements EditOperation {
+  async do(
+    edit: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (edit.type !== "removegraph") {
+      throw new Error(
+        `Editor API integrity error: expected type "removegraph", received "${edit.type}" instead.`
+      );
+    }
+    const { id } = edit;
+    const { graph, mutable } = context;
+
+    if (!graph.graphs || !graph.graphs?.[id]) {
+      return {
+        success: false,
+        error: `Failed to remove graph: "${id}" does not exist.`,
+      };
+    }
+    delete graph.graphs[id];
+    if (!Object.keys(graph.graphs).length) {
+      delete graph.graphs;
+    }
+    mutable.removeSubgraph(id);
+
+    return {
+      success: true,
+      affectedModules: [],
+      affectedNodes: [],
+      affectedGraphs: [id],
+    };
+  }
+}

package/src/breadboard/engine/editor/operations/remove-integration.ts

@@ -0,0 +1,54 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+
+export { RemoveIntegration };
+
+class RemoveIntegration implements EditOperation {
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "removeintegration") {
+      throw new Error(
+        `Editor API integrity error: expected type "removeintegration", received "${spec.type}" instead.`
+      );
+    }
+
+    const { id } = spec;
+
+    const {
+      graph: { integrations },
+    } = context;
+
+    let noChange = false;
+
+    if (integrations?.[id]) {
+      delete integrations[id];
+      if (Object.keys(integrations).length === 0) {
+        delete context.graph.integrations;
+      }
+    } else {
+      noChange = true;
+    }
+
+    return {
+      success: true,
+      affectedGraphs: [],
+      affectedModules: [],
+      affectedNodes: [],
+      integrationsChange: true,
+      noChange,
+    };
+  }
+}

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

@@ -0,0 +1,69 @@
+// @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 RemoveModule implements EditOperation {
+  async can(
+    id: ModuleIdentifier,
+    inspector: InspectableGraph
+  ): Promise<SingleEditResult> {
+    if (!inspector.moduleById(id)) {
+      return {
+        success: false,
+        error: `Module "${id}" does not exist`,
+      };
+    }
+    return {
+      success: true,
+      affectedNodes: [],
+      affectedModules: [id],
+      affectedGraphs: [],
+    };
+  }
+
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "removemodule") {
+      throw new Error(
+        `Editor API integrity error: expected type "removemodule", received "${spec.type}" instead.`
+      );
+    }
+    const { id } = spec;
+    const { graph, mutable } = context;
+    const inspector = mutable.graphs.get("")!;
+    const can = await this.can(id, inspector);
+    if (!can.success) {
+      return can;
+    }
+
+    if (!graph.modules) {
+      return {
+        success: false,
+        error: `Modules do not exist on graph`,
+      };
+    }
+
+    delete graph.modules[id];
+
+    return {
+      success: true,
+      affectedNodes: [],
+      affectedModules: [id],
+      affectedGraphs: [],
+    };
+  }
+}

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

@@ -0,0 +1,86 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  GraphIdentifier,
+  InspectableGraph,
+  NodeIdentifier,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+import { GraphDescriptorHandle } from "../../inspector/graph/graph-descriptor-handle.js";
+import { errorNoInspect } from "./error.js";
+
+export class RemoveNode implements EditOperation {
+  async can(
+    id: NodeIdentifier,
+    inspector: InspectableGraph,
+    graphId: GraphIdentifier
+  ): Promise<SingleEditResult> {
+    const exists = !!inspector.nodeById(id);
+    if (!exists) {
+      return {
+        success: false,
+        error: `Unable to remove node: node with id "${id}" does not exist`,
+      };
+    }
+    return {
+      success: true,
+      affectedNodes: [{ id, graphId }],
+      affectedModules: [],
+      affectedGraphs: [],
+      topologyChange: true,
+    };
+  }
+
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "removenode") {
+      throw new Error(
+        `Editor API integrity error: expected type "removenode", received "${spec.type}" instead.`
+      );
+    }
+    const { id, graphId } = spec;
+    const { mutable } = context;
+    const inspector = mutable.graphs.get(graphId);
+    if (!inspector) {
+      return errorNoInspect(graphId);
+    }
+    const can = await this.can(id, inspector, graphId);
+    if (!can.success) {
+      return can;
+    }
+    const handle = GraphDescriptorHandle.create(context.graph, graphId);
+    if (!handle.success) {
+      return handle;
+    }
+    const graph = handle.result.graph();
+
+    // Remove any edges that are connected to the removed node.
+    graph.edges = graph.edges.filter((edge) => {
+      const shouldRemove = edge.from === id || edge.to === id;
+      if (shouldRemove) {
+        mutable.edges.remove(edge, graphId);
+      }
+      return !shouldRemove;
+    });
+    // Remove the node from the graph.
+    graph.nodes = graph.nodes.filter((node) => node.id != id);
+    mutable.nodes.remove(id, graphId);
+    return {
+      success: true,
+      affectedNodes: [{ id, graphId }],
+      affectedModules: [],
+      affectedGraphs: [graphId],
+      topologyChange: true,
+    };
+  }
+}

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

@@ -0,0 +1,52 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+
+export class ReplaceGraph implements EditOperation {
+  async do(
+    edit: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (edit.type !== "replacegraph") {
+      throw new Error(
+        `Editor API integrity error: expected type "replacegraph", received "${edit.type}" instead.`
+      );
+    }
+
+    // Do a full in-place replacement of the graph. Re-assigning onto context
+    // won't work because the object itself is captured and used elsewhere.
+    const originalUrl = context.graph.url;
+    for (const key in context.graph) {
+      if (Object.prototype.hasOwnProperty.call(context.graph, key)) {
+        delete context.graph[key as keyof typeof context.graph];
+      }
+    }
+    Object.assign(context.graph, edit.replacement);
+    // Ensure the URL doesn't change; it's very important.
+    context.graph.url = originalUrl;
+
+    // Also update the "mutable" graph, which is actually a bunch of caches for
+    // the UI that are not automatically synchronized with the actual graph.
+    context.mutable.rebuild(edit.replacement);
+
+    return {
+      success: true,
+      // We don't need to include any affected things, because rebuild replaces
+      // them anyway.
+      affectedModules: [],
+      affectedNodes: [],
+      affectedGraphs: [],
+      topologyChange: true,
+    };
+  }
+}

package/src/breadboard/engine/editor/operations/toggle-export.ts

@@ -0,0 +1,72 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  GraphIdentifier,
+  ModuleIdentifier,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+
+export class ToggleExport implements EditOperation {
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "toggleexport") {
+      throw new Error(
+        `Editor API integrity error: expected type "toggleexport", received "${spec.type}" instead.`
+      );
+    }
+    const { id, exportType: type } = spec;
+    const { mutable } = context;
+
+    let exportId;
+    const affectedGraphs: GraphIdentifier[] = [];
+    const affectedModules: ModuleIdentifier[] = [];
+
+    if (type === "imperative") {
+      // toggle module export.
+      const moduleId = id as ModuleIdentifier;
+      if (!mutable.graph.modules?.[moduleId]) {
+        return {
+          success: false,
+          error: `Unable to toggle export: module "${moduleId}" does not exist.`,
+        };
+      }
+      exportId = `#module:${id}`;
+      affectedModules.push(id);
+    } else {
+      // toggle graph export.
+      const graphId = id as GraphIdentifier;
+      if (graphId !== "" && !mutable.graph.graphs?.[graphId]) {
+        return {
+          success: false,
+          error: `Unable to toggle export: graph "${graphId}" does not exist.`,
+        };
+      }
+      exportId = `#${id}`;
+      affectedGraphs.push(id);
+    }
+
+    const exports = new Set(mutable.graph.exports || []);
+    if (exports.has(exportId)) {
+      exports.delete(exportId);
+    } else {
+      exports.add(exportId);
+    }
+    mutable.graph.exports = [...exports];
+    return {
+      success: true,
+      affectedNodes: [],
+      affectedModules,
+      affectedGraphs,
+    };
+  }
+}

package/src/breadboard/engine/editor/operations/upsert-integration.ts

@@ -0,0 +1,43 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EditOperation,
+  EditOperationContext,
+  EditSpec,
+  SingleEditResult,
+} from "@breadboard-ai/types";
+
+export { UpsertInteration };
+
+class UpsertInteration implements EditOperation {
+  async do(
+    spec: EditSpec,
+    context: EditOperationContext
+  ): Promise<SingleEditResult> {
+    if (spec.type !== "upsertintegration") {
+      throw new Error(
+        `Editor API integrity error: expected type "upsertintegration", received "${spec.type}" instead.`
+      );
+    }
+
+    const { id, integration } = spec;
+
+    const { graph } = context;
+
+    graph.integrations ??= {};
+    graph.integrations[id] = integration;
+
+    return {
+      success: true,
+      affectedGraphs: [],
+      affectedModules: [],
+      affectedNodes: [],
+      integrationsChange: true,
+    };
+  }
+}