windmill-components 1.677.1 → 1.687.0

package/package/components/flows/flowDeleteUtils.js

@@ -0,0 +1,150 @@
+import { findInStructure } from '../graph/flowStructure';
+import { collectAgentToolIds, collectFlowNodeIds, findAgentToolOwner, removeAgentToolOwner } from './agentToolTree';
+import { dfs } from './dfs';
+import { getDependentComponents } from './flowExplorer';
+import { findModuleInModules } from './flowTree';
+export function resolveDeleteTargets(tree, modules, ids, hasPreprocessor) {
+    const targets = [];
+    const missingIds = [];
+    const seenIds = new Set();
+    for (const id of ids) {
+        if (seenIds.has(id)) {
+            continue;
+        }
+        seenIds.add(id);
+        if (id === 'preprocessor') {
+            if (hasPreprocessor) {
+                targets.push({ kind: 'preprocessor', id, stateIds: [id] });
+            }
+            else {
+                missingIds.push(id);
+            }
+            continue;
+        }
+        if (findInStructure(tree, id)) {
+            const module = findModuleInModules(modules, id);
+            if (module) {
+                targets.push({
+                    kind: 'structure_node',
+                    id,
+                    stateIds: collectFlowNodeIds(module)
+                });
+                continue;
+            }
+        }
+        const owner = findAgentToolOwner(modules, id);
+        if (owner) {
+            targets.push({
+                kind: 'agent_tool',
+                id,
+                stateIds: collectAgentToolIds(owner.tool)
+            });
+            continue;
+        }
+        missingIds.push(id);
+    }
+    return {
+        targets: pruneNestedTargets(targets),
+        missingIds
+    };
+}
+export function createDeletePlan(args) {
+    const { targets } = resolveDeleteTargets(args.tree, args.flow.value.modules, args.ids, Boolean(args.flow.value.preprocessor_module));
+    if (targets.length === 0) {
+        return undefined;
+    }
+    const structureIds = targets
+        .filter((target) => target.kind === 'structure_node')
+        .map((target) => target.id);
+    const structureDelete = structureIds.length > 0
+        ? args.proxy.prepareDelete(structureIds, { displayState: args.displayState })
+        : undefined;
+    const plannedStateIds = uniqueIds(targets.flatMap((target) => target.stateIds));
+    return {
+        inputIds: args.ids,
+        targets,
+        plannedStateIds,
+        dependents: collectDeleteDependents(plannedStateIds, args.flow),
+        selection: getDeleteSelection(args.ids, plannedStateIds, args.flow.value.modules),
+        structureDelete,
+        removeDuplicates: Boolean(structureDelete?.duplicateGroups.length)
+    };
+}
+export function removeDeletePlanTools(targets, modules, onRemove) {
+    const removedIds = new Set();
+    const toolTargets = targets
+        .filter((target) => target.kind === 'agent_tool')
+        .map((target) => findAgentToolOwner(modules, target.id))
+        .filter((owner) => Boolean(owner))
+        .sort((left, right) => {
+        if (left.depth !== right.depth) {
+            return right.depth - left.depth;
+        }
+        if (left.tools === right.tools) {
+            return right.toolIndex - left.toolIndex;
+        }
+        return 0;
+    });
+    for (const owner of toolTargets) {
+        const removed = removeAgentToolOwner(owner);
+        if (!removed) {
+            continue;
+        }
+        onRemove?.(removed.tool);
+        for (const id of removed.removedIds) {
+            removedIds.add(id);
+        }
+    }
+    return [...removedIds];
+}
+function pruneNestedTargets(targets) {
+    const descendantIds = new Set();
+    for (const target of targets) {
+        for (const stateId of target.stateIds) {
+            if (stateId !== target.id) {
+                descendantIds.add(stateId);
+            }
+        }
+    }
+    return targets.filter((target) => !descendantIds.has(target.id));
+}
+function collectDeleteDependents(ids, flow) {
+    const deletingSet = new Set(ids);
+    const dependents = {};
+    for (const id of ids) {
+        const dependencies = getDependentComponents(id, flow);
+        for (const [dependentId, expressions] of Object.entries(dependencies)) {
+            if (deletingSet.has(dependentId)) {
+                continue;
+            }
+            dependents[dependentId] = [...(dependents[dependentId] ?? []), ...expressions];
+        }
+    }
+    return dependents;
+}
+function getDeleteSelection(ids, deletedIds, modules) {
+    if (ids.length !== 1) {
+        return { kind: 'clear' };
+    }
+    const [id] = ids;
+    if (id === 'preprocessor') {
+        return { kind: 'select', id: 'Input' };
+    }
+    const orderedIds = dfs(modules, (module) => module.id);
+    const index = orderedIds.indexOf(id);
+    const deletedSet = new Set(deletedIds);
+    for (let i = index - 1; i >= 0; i--) {
+        if (!deletedSet.has(orderedIds[i])) {
+            return { kind: 'select', id: orderedIds[i] };
+        }
+    }
+    for (let i = index + 1; i < orderedIds.length; i++) {
+        if (!deletedSet.has(orderedIds[i])) {
+            return { kind: 'select', id: orderedIds[i] };
+        }
+    }
+    return { kind: 'select', id: 'settings-metadata' };
+}
+function uniqueIds(ids) {
+    return [...new Set(ids)];
+}

package/package/components/flows/flowDeleteUtils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package/components/flows/flowDeleteUtils.test.js

@@ -0,0 +1,131 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('../aiProviderStorage', () => ({
+    loadStoredConfig: () => undefined
+}));
+vi.mock('./flowInfers', () => ({
+    AI_AGENT_SCHEMA: { properties: {} }
+}));
+import { GroupDisplayState } from '../graph/groupEditor.svelte';
+import { createDeletePlan, removeDeletePlanTools, resolveDeleteTargets } from './flowDeleteUtils';
+function makeRawModule(id, expr) {
+    return {
+        id,
+        summary: id,
+        value: {
+            type: 'rawscript',
+            content: '',
+            language: 'python3',
+            input_transforms: expr
+                ? {
+                    user_input: {
+                        type: 'javascript',
+                        expr
+                    }
+                }
+                : {}
+        }
+    };
+}
+function makeAiAgent(id, tools) {
+    return {
+        id,
+        summary: id,
+        value: {
+            type: 'aiagent',
+            tools,
+            input_transforms: {}
+        }
+    };
+}
+function makeFlowModuleTool(module) {
+    return {
+        id: module.id,
+        summary: module.summary,
+        value: {
+            tool_type: 'flowmodule',
+            ...module.value
+        }
+    };
+}
+describe('resolveDeleteTargets', () => {
+    it('resolves structure nodes, preprocessor, and ai tools while pruning nested descendants', () => {
+        const rootAgent = makeAiAgent('root_agent', [
+            makeFlowModuleTool(makeRawModule('lookup_user')),
+            makeFlowModuleTool(makeAiAgent('support_agent', [makeFlowModuleTool(makeRawModule('create_ticket'))]))
+        ]);
+        const tree = [{ id: 'root_agent', kind: 'leaf', branches: [] }];
+        const { targets, missingIds } = resolveDeleteTargets(tree, [rootAgent], ['preprocessor', 'root_agent', 'create_ticket', 'missing_tool'], true);
+        expect(targets.map((target) => target.kind)).toEqual(['preprocessor', 'structure_node']);
+        expect(targets[1].stateIds).toEqual([
+            'root_agent',
+            'lookup_user',
+            'support_agent',
+            'create_ticket'
+        ]);
+        expect(missingIds).toEqual(['missing_tool']);
+    });
+});
+describe('createDeletePlan', () => {
+    it('collects subtree dependents and routes structure deletes through the proxy helper', () => {
+        const agent = makeAiAgent('agent_step', [makeFlowModuleTool(makeRawModule('lookup_user'))]);
+        const dependent = makeRawModule('dependent_step', 'results.lookup_user?.value');
+        const flow = {
+            summary: 'Flow',
+            value: {
+                modules: [agent, dependent]
+            }
+        };
+        const tree = [
+            { id: 'agent_step', kind: 'leaf', branches: [] },
+            { id: 'dependent_step', kind: 'leaf', branches: [] }
+        ];
+        const commit = vi.fn();
+        const prepareDelete = vi.fn(() => ({
+            affectedGroups: [],
+            duplicateGroups: [],
+            commit
+        }));
+        const proxy = {
+            prepareDelete
+        };
+        const plan = createDeletePlan({
+            ids: ['agent_step'],
+            flow,
+            tree,
+            proxy,
+            displayState: new GroupDisplayState(() => [])
+        });
+        expect(prepareDelete).toHaveBeenCalledWith(['agent_step'], expect.any(Object));
+        expect(plan?.plannedStateIds).toEqual(['agent_step', 'lookup_user']);
+        expect(plan?.structureDelete?.affectedGroups).toEqual([]);
+        expect(plan?.dependents).toEqual({
+            dependent_step: ['results.lookup_user?.value']
+        });
+        expect(plan?.selection).toEqual({ kind: 'select', id: 'dependent_step' });
+    });
+});
+describe('removeDeletePlanTools', () => {
+    it('removes nested tools before their parents and returns every removed id', () => {
+        const rootAgent = makeAiAgent('root_agent', [
+            makeFlowModuleTool(makeAiAgent('support_agent', [makeFlowModuleTool(makeRawModule('create_ticket'))]))
+        ]);
+        const tree = [];
+        const { targets } = resolveDeleteTargets(tree, [rootAgent], ['support_agent', 'create_ticket'], false);
+        expect(removeDeletePlanTools(targets, [rootAgent])).toEqual(['support_agent', 'create_ticket']);
+        expect(rootAgent.value.tools).toEqual([]);
+    });
+    it('re-resolves live owners before removing planned tool targets', () => {
+        const rootAgent = makeAiAgent('root_agent', [
+            makeFlowModuleTool(makeRawModule('lookup_user')),
+            makeFlowModuleTool(makeAiAgent('support_agent', [makeFlowModuleTool(makeRawModule('create_ticket'))]))
+        ]);
+        const tree = [];
+        const { targets } = resolveDeleteTargets(tree, [rootAgent], ['support_agent'], false);
+        rootAgent.value.tools.unshift(makeFlowModuleTool(makeRawModule('new_lookup')));
+        expect(removeDeletePlanTools(targets, [rootAgent])).toEqual(['support_agent', 'create_ticket']);
+        expect(rootAgent.value.tools.map((tool) => tool.id)).toEqual([
+            'new_lookup',
+            'lookup_user'
+        ]);
+    });
+});

package/package/components/flows/flowDiff.d.ts

@@ -1,4 +1,6 @@
 import type { FlowModule, FlowValue } from '../../gen';
+import { type ModuleParentLocation } from './flowTree';
+export { findModuleInFlow, findModuleParent, type ModuleParentLocation } from './flowTree';
 /** Prefix added to module IDs when the original module coexists with a replacement */
 export declare const DUPLICATE_MODULE_PREFIX = "old__";
 /** Prefix added to new module IDs when restoring original during type change rejection */
@@ -52,45 +54,6 @@ export declare function computeFlowModuleDiff(beforeFlow: FlowValue, afterFlow:
  * Index within the container is not considered (modules can be reordered).
  */
 export declare function locationsEqual(a: ModuleParentLocation | null, b: ModuleParentLocation | null): boolean;
-/**
- * Represents the parent location of a module
- */
-export type ModuleParentLocation = {
-    type: 'root';
-    index: number;
-} | {
-    type: 'forloop' | 'whileloop';
-    parentId: string;
-    index: number;
-} | {
-    type: 'branchone-default';
-    parentId: string;
-    index: number;
-} | {
-    type: 'branchone-branch';
-    parentId: string;
-    branchIndex: number;
-    index: number;
-} | {
-    type: 'branchall-branch';
-    parentId: string;
-    branchIndex: number;
-    index: number;
-} | {
-    type: 'aiagent';
-    parentId: string;
-    index: number;
-} | {
-    type: 'failure';
-    index: -1;
-} | {
-    type: 'preprocessor';
-    index: -1;
-};
-/**
- * Finds the parent location of a module in a flow
- */
-export declare function findModuleParent(flow: FlowValue, moduleId: string): ModuleParentLocation | null;
 /**
  * Builds the complete flow diff result with action maps and merged flow.
  * The merged flow contains all modules from afterFlow plus removed modules from
@@ -115,14 +78,6 @@ export declare function buildFlowTimeline(beforeFlow: FlowValue, afterFlow: Flow
  * @param moduleId - The ID of the module being inserted
  */
 export declare function insertModuleIntoFlow(targetFlow: FlowValue, moduleToInsert: FlowModule, sourceFlow: FlowValue, moduleId: string): void;
-/**
- * Finds a module by ID anywhere in a flow (including nested modules, failure, and preprocessor)
- *
- * @param flow - The flow to search in
- * @param moduleId - The ID of the module to find
- * @returns The module if found, null otherwise
- */
-export declare function findModuleInFlow(flow: FlowValue, moduleId: string): FlowModule | null;
 /**
  * Checks if the input schema has changed between two flow versions.
  * The input schema always exists (even if empty), so we only check for modifications.