@synergenius/flow-weaver 0.20.1 → 0.20.3

package/dist/annotation-generator.js

@@ -596,6 +596,12 @@ export function generateNodeInstanceTag(instance) {
         const tagEntries = instance.config.tags.map(t => t.tooltip ? `"${t.label}" "${t.tooltip}"` : `"${t.label}"`).join(', ');
         tagsAttr = ` [tags: ${tagEntries}]`;
     }
+    // Generate [suppress: "CODE", "CODE2"] attribute if present
+    let suppressAttr = '';
+    if (instance.config?.suppressWarnings?.length) {
+        const codes = instance.config.suppressWarnings.map(c => `"${c}"`).join(', ');
+        suppressAttr = ` [suppress: ${codes}]`;
+    }
     // Generate [size: width height] attribute if present
     let sizeAttr = '';
     if (instance.config?.width !== undefined && instance.config?.height !== undefined) {
@@ -606,7 +612,7 @@ export function generateNodeInstanceTag(instance) {
     if (instance.config?.x !== undefined && instance.config?.y !== undefined) {
         positionAttr = ` [position: ${Math.round(instance.config.x)} ${Math.round(instance.config.y)}]`;
     }
-    return ` * @node ${instance.id} ${instance.nodeType}${parent}${labelAttr}${portOrderAttr}${portLabelAttr}${exprAttr}${pullExecutionAttr}${minimizedAttr}${colorAttr}${iconAttr}${tagsAttr}${sizeAttr}${positionAttr}`;
+    return ` * @node ${instance.id} ${instance.nodeType}${parent}${labelAttr}${portOrderAttr}${portLabelAttr}${exprAttr}${pullExecutionAttr}${minimizedAttr}${colorAttr}${iconAttr}${tagsAttr}${suppressAttr}${sizeAttr}${positionAttr}`;
 }
 /**
  * Generate a TypeScript function signature from a node type definition.

package/dist/api/index.d.ts

@@ -38,6 +38,7 @@ export { transformWorkflow } from './transform.js';
 export { type ValidationResult, validateWorkflow } from './validate.js';
 export { validationRuleRegistry } from './validation-registry.js';
 export * from './manipulation/index.js';
+export { applyModifyOperation, validateModifyParams } from './modify-operation.js';
 export { withValidation, withMinimalValidation, withoutValidation, type RemoveOptions, type NodeFilter, type OperationResult, validatePortReference, portReferencesEqual, formatPortReference, generateUniqueNodeId, assertNodeTypeExists, assertNodeExists, assertNodeNotExists, } from './helpers.js';
 export * from './query.js';
 export * from './builder.js';

package/dist/api/index.js

@@ -37,6 +37,7 @@ export { transformWorkflow } from './transform.js';
 export { validateWorkflow } from './validate.js';
 export { validationRuleRegistry } from './validation-registry.js';
 export * from './manipulation/index.js';
+export { applyModifyOperation, validateModifyParams } from './modify-operation.js';
 export { withValidation, withMinimalValidation, withoutValidation, validatePortReference, portReferencesEqual, formatPortReference, generateUniqueNodeId, assertNodeTypeExists, assertNodeExists, assertNodeNotExists, } from './helpers.js';
 export * from './query.js';
 export * from './builder.js';

package/dist/api/modify-operation.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { TWorkflowAST } from '../ast/types.js';
+export declare const modifyParamsSchemas: Record<string, z.ZodType>;
+export declare function validateModifyParams(operation: string, params: Record<string, unknown>): {
+    success: true;
+} | {
+    success: false;
+    error: string;
+};
+export declare function applyModifyOperation(ast: TWorkflowAST, operation: string, params: Record<string, unknown>): {
+    ast: TWorkflowAST;
+    warnings: string[];
+    extraData: Record<string, unknown>;
+};
+//# sourceMappingURL=modify-operation.d.ts.map

package/dist/api/modify-operation.js

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+import { addNode as manipAddNode, removeNode as manipRemoveNode, renameNode as manipRenameNode, addConnection as manipAddConnection, removeConnection as manipRemoveConnection, setNodePosition as manipSetNodePosition, setNodeLabel as manipSetNodeLabel, } from './manipulation/index.js';
+import { findIsolatedNodes } from './query.js';
+export const modifyParamsSchemas = {
+    addNode: z.object({
+        nodeId: z.string({ required_error: 'nodeId is required' }),
+        nodeType: z.string({ required_error: 'nodeType is required' }),
+        x: z.number().optional(),
+        y: z.number().optional(),
+    }),
+    removeNode: z.object({
+        nodeId: z.string({ required_error: 'nodeId is required' }),
+    }),
+    renameNode: z.object({
+        oldId: z.string({ required_error: 'oldId is required' }),
+        newId: z.string({ required_error: 'newId is required' }),
+    }),
+    addConnection: z.object({
+        from: z.string({ required_error: 'from is required (format: "node.port")' }),
+        to: z.string({ required_error: 'to is required (format: "node.port")' }),
+    }),
+    removeConnection: z.object({
+        from: z.string({ required_error: 'from is required (format: "node.port")' }),
+        to: z.string({ required_error: 'to is required (format: "node.port")' }),
+    }),
+    setNodePosition: z.object({
+        nodeId: z.string({ required_error: 'nodeId is required' }),
+        x: z.number({ required_error: 'x is required', invalid_type_error: 'x must be a number' }),
+        y: z.number({ required_error: 'y is required', invalid_type_error: 'y must be a number' }),
+    }),
+    setNodeLabel: z.object({
+        nodeId: z.string({ required_error: 'nodeId is required' }),
+        label: z.string({ required_error: 'label is required' }),
+    }),
+};
+export function validateModifyParams(operation, params) {
+    const schema = modifyParamsSchemas[operation];
+    if (!schema) {
+        return { success: false, error: `Unknown operation: ${operation}` };
+    }
+    const result = schema.safeParse(params);
+    if (!result.success) {
+        const messages = result.error.issues.map((i) => i.message).join('; ');
+        return { success: false, error: `${operation} params invalid: ${messages}` };
+    }
+    return { success: true };
+}
+export function applyModifyOperation(ast, operation, params) {
+    const p = params;
+    const warnings = [];
+    const extraData = {};
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- AST manipulation functions use loose typing
+    let modifiedAST = ast;
+    switch (operation) {
+        case 'addNode': {
+            const nodeId = p.nodeId;
+            const nodeType = p.nodeType;
+            const nodeTypeExists = modifiedAST.nodeTypes.some((nt) => nt.name === nodeType || nt.functionName === nodeType);
+            if (!nodeTypeExists) {
+                warnings.push(`Node type "${nodeType}" is not defined in the file. ` +
+                    `The node will be added but may not render until the type is defined.`);
+            }
+            let autoX = typeof p.x === 'number' ? p.x : undefined;
+            let autoY = typeof p.y === 'number' ? p.y : undefined;
+            if (autoX === undefined || autoY === undefined) {
+                const positions = modifiedAST.instances
+                    .map((inst) => inst.config)
+                    .filter((c) => c !== undefined &&
+                    c !== null &&
+                    typeof c.x === 'number' &&
+                    typeof c.y === 'number');
+                if (positions.length > 0) {
+                    const maxX = Math.max(...positions.map((pos) => pos.x));
+                    if (autoX === undefined)
+                        autoX = maxX + 180;
+                    if (autoY === undefined)
+                        autoY = 0;
+                }
+                else {
+                    if (autoX === undefined)
+                        autoX = 0;
+                    if (autoY === undefined)
+                        autoY = 0;
+                }
+            }
+            modifiedAST = manipAddNode(modifiedAST, {
+                type: 'NodeInstance',
+                id: nodeId,
+                nodeType,
+                config: { x: autoX, y: autoY },
+            });
+            break;
+        }
+        case 'removeNode': {
+            const nodeId = p.nodeId;
+            const removedConnections = modifiedAST.connections
+                .filter((c) => c.from.node === nodeId || c.to.node === nodeId)
+                .map((c) => ({
+                from: `${c.from.node}.${c.from.port}`,
+                to: `${c.to.node}.${c.to.port}`,
+            }));
+            modifiedAST = manipRemoveNode(modifiedAST, nodeId);
+            if (removedConnections.length > 0) {
+                extraData.removedConnections = removedConnections;
+            }
+            break;
+        }
+        case 'renameNode': {
+            modifiedAST = manipRenameNode(modifiedAST, p.oldId, p.newId);
+            break;
+        }
+        case 'addConnection': {
+            const from = p.from;
+            const to = p.to;
+            const [fromNode, fromPort] = from.split('.');
+            const [toNode, toPort] = to.split('.');
+            if (!fromPort || !toPort) {
+                throw new Error('Connection format must be "node.port" (e.g., "Start.execute")');
+            }
+            const validNodes = [
+                'Start',
+                'Exit',
+                ...modifiedAST.instances.map((i) => i.id),
+            ];
+            if (!validNodes.includes(fromNode)) {
+                throw new Error(`Source node "${fromNode}" not found. Available: ${validNodes.join(', ')}`);
+            }
+            if (!validNodes.includes(toNode)) {
+                throw new Error(`Target node "${toNode}" not found. Available: ${validNodes.join(', ')}`);
+            }
+            if (fromNode !== 'Start' && fromNode !== 'Exit') {
+                const inst = modifiedAST.instances.find((i) => i.id === fromNode);
+                const nt = modifiedAST.nodeTypes.find((t) => t.name === inst?.nodeType);
+                if (nt && !nt.outputs[fromPort]) {
+                    throw new Error(`Node "${fromNode}" has no output "${fromPort}". Available: ${Object.keys(nt.outputs).join(', ')}`);
+                }
+            }
+            if (toNode !== 'Start' && toNode !== 'Exit') {
+                const inst = modifiedAST.instances.find((i) => i.id === toNode);
+                const nt = modifiedAST.nodeTypes.find((t) => t.name === inst?.nodeType);
+                if (nt && !nt.inputs[toPort]) {
+                    throw new Error(`Node "${toNode}" has no input "${toPort}". Available: ${Object.keys(nt.inputs).join(', ')}`);
+                }
+            }
+            modifiedAST = manipAddConnection(modifiedAST, from, to);
+            if (modifiedAST.options?.autoConnect) {
+                modifiedAST = { ...modifiedAST, options: { ...modifiedAST.options, autoConnect: undefined } };
+                warnings.push('autoConnect was disabled because connections were manually modified');
+            }
+            break;
+        }
+        case 'removeConnection': {
+            modifiedAST = manipRemoveConnection(modifiedAST, p.from, p.to);
+            if (modifiedAST.options?.autoConnect) {
+                modifiedAST = { ...modifiedAST, options: { ...modifiedAST.options, autoConnect: undefined } };
+                warnings.push('autoConnect was disabled because connections were manually modified');
+            }
+            const newlyIsolated = findIsolatedNodes(modifiedAST);
+            if (newlyIsolated.length > 0) {
+                extraData.newlyIsolatedNodes = newlyIsolated;
+            }
+            break;
+        }
+        case 'setNodePosition': {
+            modifiedAST = manipSetNodePosition(modifiedAST, p.nodeId, p.x, p.y);
+            break;
+        }
+        case 'setNodeLabel': {
+            modifiedAST = manipSetNodeLabel(modifiedAST, p.nodeId, p.label);
+            break;
+        }
+        default:
+            throw new Error(`Unknown operation: ${operation}`);
+    }
+    return { ast: modifiedAST, warnings, extraData };
+}
+//# sourceMappingURL=modify-operation.js.map

package/dist/api/validate.js

@@ -38,6 +38,23 @@ export function validateWorkflow(ast, options) {
             }
         }
     }
+    // Filter warnings from additional rules through per-instance suppressWarnings
+    // (core validator already filters its own warnings, but agent/registry rules
+    // run after the core validator and need the same treatment)
+    const suppressMap = new Map();
+    for (const inst of ast.instances) {
+        if (inst.config?.suppressWarnings?.length) {
+            suppressMap.set(inst.id, new Set(inst.config.suppressWarnings));
+        }
+    }
+    if (suppressMap.size > 0) {
+        result.warnings = result.warnings.filter((w) => {
+            if (!w.node)
+                return true;
+            const codes = suppressMap.get(w.node);
+            return !codes || !codes.has(w.code);
+        });
+    }
     // Re-evaluate validity
     result.valid = result.errors.length === 0;
     return result;

package/dist/ast/types.d.ts

@@ -345,6 +345,8 @@ export type TNodeInstanceConfig = {
     minimized?: boolean;
     width?: number;
     height?: number;
+    /** Warning codes to suppress for this instance (e.g., ["UNUSED_OUTPUT_PORT"]) */
+    suppressWarnings?: string[];
 };
 /**
  * Node Instance AST - A usage of a node type in a workflow.

package/dist/chevrotain-parser/node-parser.d.ts

@@ -31,6 +31,8 @@ export interface NodeParseResult {
     job?: string;
     /** CI/CD deployment environment */
     environment?: string;
+    /** Warning codes to suppress for this instance */
+    suppress?: string[];
 }
 /**
  * Parse a @node line and return structured result.

package/dist/chevrotain-parser/node-parser.js

@@ -4,7 +4,7 @@
  * Parser for @node declarations using Chevrotain.
  */
 import { CstParser } from 'chevrotain';
-import { JSDocLexer, NodeTag, Identifier, Dot, Integer, LabelPrefix, ExprPrefix, PortOrderPrefix, PortLabelPrefix, MinimizedKeyword, PullExecutionPrefix, SizePrefix, PositionPrefix, ColorPrefix, IconPrefix, JobPrefix, EnvironmentAttrPrefix, TagsPrefix, StringLiteral, LBracket, RBracket, Comma, Equals, EventEq, CronEq, MatchEq, TimeoutEq, LimitEq, PeriodEq, allTokens, } from './tokens.js';
+import { JSDocLexer, NodeTag, Identifier, Dot, Integer, LabelPrefix, ExprPrefix, PortOrderPrefix, PortLabelPrefix, MinimizedKeyword, PullExecutionPrefix, SizePrefix, PositionPrefix, ColorPrefix, IconPrefix, JobPrefix, EnvironmentAttrPrefix, TagsPrefix, SuppressPrefix, StringLiteral, LBracket, RBracket, Comma, Equals, EventEq, CronEq, MatchEq, TimeoutEq, LimitEq, PeriodEq, allTokens, } from './tokens.js';
 // =============================================================================
 // Parser Definition
 // =============================================================================
@@ -54,6 +54,7 @@ class NodeParser extends CstParser {
                     { ALT: () => this.SUBRULE(this.jobAttr) },
                     { ALT: () => this.SUBRULE(this.environmentAttr) },
                     { ALT: () => this.SUBRULE(this.tagsAttr) },
+                    { ALT: () => this.SUBRULE(this.suppressAttr) },
                 ]);
             },
         });
@@ -179,6 +180,16 @@ class NodeParser extends CstParser {
             },
         });
     });
+    // suppress: "CODE", "CODE2"
+    suppressAttr = this.RULE('suppressAttr', () => {
+        this.CONSUME(SuppressPrefix);
+        this.AT_LEAST_ONE_SEP({
+            SEP: Comma,
+            DEF: () => {
+                this.CONSUME(StringLiteral, { LABEL: 'suppressCode' });
+            },
+        });
+    });
     // "label" ["tooltip"]
     tagEntry = this.RULE('tagEntry', () => {
         this.CONSUME(StringLiteral, { LABEL: 'tagLabel' });
@@ -217,6 +228,7 @@ class NodeVisitor extends BaseVisitor {
         let tags;
         let job;
         let environment;
+        let suppress;
         if (ctx.parentScopeRef) {
             parentScope = this.visit(ctx.parentScopeRef);
         }
@@ -249,6 +261,8 @@ class NodeVisitor extends BaseVisitor {
                     job = attrs.job;
                 if (attrs.environment)
                     environment = attrs.environment;
+                if (attrs.suppress)
+                    suppress = [...(suppress || []), ...attrs.suppress];
             }
         }
         return {
@@ -268,6 +282,7 @@ class NodeVisitor extends BaseVisitor {
             ...(tags && { tags }),
             ...(job && { job }),
             ...(environment && { environment }),
+            ...(suppress && { suppress }),
         };
     }
     parentScopeRef(ctx) {
@@ -289,6 +304,7 @@ class NodeVisitor extends BaseVisitor {
         let tags;
         let job;
         let environment;
+        let suppress;
         if (ctx.labelAttr) {
             for (const attr of ctx.labelAttr) {
                 label = this.visit(attr);
@@ -356,6 +372,12 @@ class NodeVisitor extends BaseVisitor {
                 environment = this.visit(attr);
             }
         }
+        if (ctx.suppressAttr) {
+            for (const attr of ctx.suppressAttr) {
+                const codes = this.visit(attr);
+                suppress = [...(suppress || []), ...codes];
+            }
+        }
         return {
             label,
             expressions,
@@ -370,6 +392,7 @@ class NodeVisitor extends BaseVisitor {
             tags,
             job,
             environment,
+            suppress,
         };
     }
     labelAttr(ctx) {
@@ -466,6 +489,9 @@ class NodeVisitor extends BaseVisitor {
     environmentAttr(ctx) {
         return this.unescapeString(ctx.environmentValue[0].image);
     }
+    suppressAttr(ctx) {
+        return ctx.suppressCode.map((tok) => this.unescapeString(tok.image));
+    }
     tagsAttr(ctx) {
         const result = [];
         if (ctx.tagEntry) {

package/dist/chevrotain-parser/tokens.d.ts

@@ -51,6 +51,7 @@ export declare const IconPrefix: import("chevrotain").TokenType;
 export declare const JobPrefix: import("chevrotain").TokenType;
 export declare const EnvironmentAttrPrefix: import("chevrotain").TokenType;
 export declare const TagsPrefix: import("chevrotain").TokenType;
+export declare const SuppressPrefix: import("chevrotain").TokenType;
 export declare const EventEq: import("chevrotain").TokenType;
 export declare const CronEq: import("chevrotain").TokenType;
 export declare const MatchEq: import("chevrotain").TokenType;

package/dist/chevrotain-parser/tokens.js

@@ -200,6 +200,10 @@ export const TagsPrefix = createToken({
     name: 'TagsPrefix',
     pattern: /tags:/,
 });
+export const SuppressPrefix = createToken({
+    name: 'SuppressPrefix',
+    pattern: /suppress:/,
+});
 export const EventEq = createToken({
     name: 'EventEq',
     pattern: /event=/,
@@ -378,6 +382,7 @@ export const allTokens = [
     JobPrefix,
     EnvironmentAttrPrefix,
     TagsPrefix,
+    SuppressPrefix,
     EventEq,
     CronEq,
     MatchEq,

package/dist/cli/commands/modify.d.ts

@@ -0,0 +1,29 @@
+export declare function modifyAddNodeCommand(file: string, opts: {
+    nodeId: string;
+    nodeType: string;
+}): Promise<void>;
+export declare function modifyRemoveNodeCommand(file: string, opts: {
+    nodeId: string;
+}): Promise<void>;
+export declare function modifyAddConnectionCommand(file: string, opts: {
+    from: string;
+    to: string;
+}): Promise<void>;
+export declare function modifyRemoveConnectionCommand(file: string, opts: {
+    from: string;
+    to: string;
+}): Promise<void>;
+export declare function modifyRenameNodeCommand(file: string, opts: {
+    oldId: string;
+    newId: string;
+}): Promise<void>;
+export declare function modifySetPositionCommand(file: string, opts: {
+    nodeId: string;
+    x: string;
+    y: string;
+}): Promise<void>;
+export declare function modifySetLabelCommand(file: string, opts: {
+    nodeId: string;
+    label: string;
+}): Promise<void>;
+//# sourceMappingURL=modify.d.ts.map

package/dist/cli/commands/modify.js

@@ -0,0 +1,57 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { parseWorkflow } from '../../api/index.js';
+import { generateInPlace } from '../../api/generate-in-place.js';
+import { applyModifyOperation, validateModifyParams } from '../../api/modify-operation.js';
+import { logger } from '../utils/logger.js';
+async function readParseModifyWrite(file, operation, params) {
+    const validation = validateModifyParams(operation, params);
+    if (!validation.success) {
+        throw new Error(validation.error);
+    }
+    const filePath = path.resolve(file);
+    const source = fs.readFileSync(filePath, 'utf-8');
+    const parseResult = await parseWorkflow(filePath);
+    if (parseResult.errors.length > 0) {
+        throw new Error(`Parse errors:\n${parseResult.errors.join('\n')}`);
+    }
+    const { ast: modifiedAST, warnings } = applyModifyOperation(parseResult.ast, operation, params);
+    const result = generateInPlace(source, modifiedAST);
+    fs.writeFileSync(filePath, result.code, 'utf-8');
+    for (const w of warnings) {
+        logger.warn(w);
+    }
+}
+export async function modifyAddNodeCommand(file, opts) {
+    await readParseModifyWrite(file, 'addNode', { nodeId: opts.nodeId, nodeType: opts.nodeType });
+    logger.success(`Added node "${opts.nodeId}" (type: ${opts.nodeType}) to ${file}`);
+}
+export async function modifyRemoveNodeCommand(file, opts) {
+    await readParseModifyWrite(file, 'removeNode', { nodeId: opts.nodeId });
+    logger.success(`Removed node "${opts.nodeId}" from ${file}`);
+}
+export async function modifyAddConnectionCommand(file, opts) {
+    await readParseModifyWrite(file, 'addConnection', { from: opts.from, to: opts.to });
+    logger.success(`Added connection ${opts.from} -> ${opts.to} in ${file}`);
+}
+export async function modifyRemoveConnectionCommand(file, opts) {
+    await readParseModifyWrite(file, 'removeConnection', { from: opts.from, to: opts.to });
+    logger.success(`Removed connection ${opts.from} -> ${opts.to} from ${file}`);
+}
+export async function modifyRenameNodeCommand(file, opts) {
+    await readParseModifyWrite(file, 'renameNode', { oldId: opts.oldId, newId: opts.newId });
+    logger.success(`Renamed node "${opts.oldId}" to "${opts.newId}" in ${file}`);
+}
+export async function modifySetPositionCommand(file, opts) {
+    await readParseModifyWrite(file, 'setNodePosition', {
+        nodeId: opts.nodeId,
+        x: Number(opts.x),
+        y: Number(opts.y),
+    });
+    logger.success(`Set position of "${opts.nodeId}" to (${opts.x}, ${opts.y}) in ${file}`);
+}
+export async function modifySetLabelCommand(file, opts) {
+    await readParseModifyWrite(file, 'setNodeLabel', { nodeId: opts.nodeId, label: opts.label });
+    logger.success(`Set label of "${opts.nodeId}" to "${opts.label}" in ${file}`);
+}
+//# sourceMappingURL=modify.js.map