@pikku/inspector 0.11.0 → 0.11.2

package/dist/utils/workflow/dsl/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * DSL (Domain Specific Language) workflow extraction exports
+ */
+export { extractDSLWorkflow } from './extract-dsl-workflow.js';
+export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './deserialize-dsl-workflow.js';
+export * from './patterns.js';
+export * from './validation.js';

package/dist/utils/workflow/dsl/index.js

@@ -0,0 +1,7 @@
+/**
+ * DSL (Domain Specific Language) workflow extraction exports
+ */
+export { extractDSLWorkflow } from './extract-dsl-workflow.js';
+export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './deserialize-dsl-workflow.js';
+export * from './patterns.js';
+export * from './validation.js';

package/dist/utils/workflow/dsl/patterns.d.ts

@@ -0,0 +1,60 @@
+import * as ts from 'typescript';
+/**
+ * Pattern detection helpers for simple workflow extraction
+ */
+/**
+ * Check if a call expression is workflow.do()
+ */
+export declare function isWorkflowDoCall(node: ts.CallExpression, checker: ts.TypeChecker): boolean;
+/**
+ * Check if a call expression is workflow.sleep()
+ */
+export declare function isWorkflowSleepCall(node: ts.CallExpression, checker: ts.TypeChecker): boolean;
+/**
+ * Check if a throw statement throws WorkflowCancelledException
+ * Matches: throw new WorkflowCancelledException(...) or throw WorkflowCancelledException(...)
+ */
+export declare function isThrowCancelException(node: ts.ThrowStatement): boolean;
+/**
+ * Extract the reason string from a throw WorkflowCancelledException statement
+ */
+export declare function extractCancelReason(node: ts.ThrowStatement, checker: ts.TypeChecker): string | undefined;
+/**
+ * Check if a call expression is array.filter()
+ */
+export declare function isArrayFilter(node: ts.CallExpression): boolean;
+/**
+ * Check if a call expression is array.some()
+ */
+export declare function isArraySome(node: ts.CallExpression): boolean;
+/**
+ * Check if a call expression is array.every()
+ */
+export declare function isArrayEvery(node: ts.CallExpression): boolean;
+/**
+ * Check if an expression is Promise.all(array.map(...))
+ */
+export declare function isParallelFanout(node: ts.CallExpression): boolean;
+/**
+ * Check if an expression is Promise.all([...])
+ */
+export declare function isParallelGroup(node: ts.CallExpression): boolean;
+/**
+ * Check if a for statement is a valid sequential fanout (for..of)
+ */
+export declare function isSequentialFanout(node: ts.ForOfStatement): boolean;
+/**
+ * Extract the variable name from a for..of statement
+ */
+export declare function extractForOfVariable(node: ts.ForOfStatement): {
+    itemVar: string;
+    sourceVar: string;
+} | null;
+/**
+ * Check if a type is an array type
+ */
+export declare function isArrayType(type: ts.Type, checker: ts.TypeChecker): boolean;
+/**
+ * Get the source text of a node (for condition expressions)
+ */
+export declare function getSourceText(node: ts.Node): string;

package/dist/utils/workflow/dsl/patterns.js

@@ -0,0 +1,218 @@
+import * as ts from 'typescript';
+/**
+ * Pattern detection helpers for simple workflow extraction
+ */
+/**
+ * Check if a call expression is workflow.do()
+ */
+export function isWorkflowDoCall(node, checker) {
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    const propAccess = node.expression;
+    return (propAccess.name.text === 'do' &&
+        ts.isIdentifier(propAccess.expression) &&
+        propAccess.expression.text === 'workflow');
+}
+/**
+ * Check if a call expression is workflow.sleep()
+ */
+export function isWorkflowSleepCall(node, checker) {
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    const propAccess = node.expression;
+    return (propAccess.name.text === 'sleep' &&
+        ts.isIdentifier(propAccess.expression) &&
+        propAccess.expression.text === 'workflow');
+}
+/**
+ * Check if a throw statement throws WorkflowCancelledException
+ * Matches: throw new WorkflowCancelledException(...) or throw WorkflowCancelledException(...)
+ */
+export function isThrowCancelException(node) {
+    const expr = node.expression;
+    if (!expr)
+        return false;
+    // Check for: throw new WorkflowCancelledException(...)
+    if (ts.isNewExpression(expr)) {
+        if (ts.isIdentifier(expr.expression)) {
+            return expr.expression.text === 'WorkflowCancelledException';
+        }
+    }
+    // Check for: throw WorkflowCancelledException(...) - function call style
+    if (ts.isCallExpression(expr)) {
+        if (ts.isIdentifier(expr.expression)) {
+            return expr.expression.text === 'WorkflowCancelledException';
+        }
+    }
+    return false;
+}
+/**
+ * Extract the reason string from a throw WorkflowCancelledException statement
+ */
+export function extractCancelReason(node, checker) {
+    const expr = node.expression;
+    if (!expr)
+        return undefined;
+    let args;
+    if (ts.isNewExpression(expr) && expr.arguments) {
+        args = expr.arguments;
+    }
+    else if (ts.isCallExpression(expr)) {
+        args = expr.arguments;
+    }
+    if (args && args.length > 0) {
+        const firstArg = args[0];
+        if (ts.isStringLiteral(firstArg)) {
+            return firstArg.text;
+        }
+        // For template literals or other expressions, return the source text
+        return firstArg.getText();
+    }
+    return undefined;
+}
+/**
+ * Check if a call expression is array.filter()
+ */
+export function isArrayFilter(node) {
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    return node.expression.name.text === 'filter';
+}
+/**
+ * Check if a call expression is array.some()
+ */
+export function isArraySome(node) {
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    return node.expression.name.text === 'some';
+}
+/**
+ * Check if a call expression is array.every()
+ */
+export function isArrayEvery(node) {
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    return node.expression.name.text === 'every';
+}
+/**
+ * Check if an expression is Promise.all(array.map(...))
+ */
+export function isParallelFanout(node) {
+    // Promise.all(...)
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    const propAccess = node.expression;
+    if (!ts.isIdentifier(propAccess.expression) ||
+        propAccess.expression.text !== 'Promise' ||
+        propAccess.name.text !== 'all') {
+        return false;
+    }
+    // Check if argument is array.map(...)
+    const arg = node.arguments[0];
+    if (!arg || !ts.isCallExpression(arg)) {
+        return false;
+    }
+    if (!ts.isPropertyAccessExpression(arg.expression)) {
+        return false;
+    }
+    return arg.expression.name.text === 'map';
+}
+/**
+ * Check if an expression is Promise.all([...])
+ */
+export function isParallelGroup(node) {
+    // Promise.all(...)
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    const propAccess = node.expression;
+    if (!ts.isIdentifier(propAccess.expression) ||
+        propAccess.expression.text !== 'Promise' ||
+        propAccess.name.text !== 'all') {
+        return false;
+    }
+    // Check if argument is an array literal
+    const arg = node.arguments[0];
+    return !!arg && ts.isArrayLiteralExpression(arg);
+}
+/**
+ * Check if a for statement is a valid sequential fanout (for..of)
+ */
+export function isSequentialFanout(node) {
+    // Must have const declaration
+    if (!ts.isVariableDeclarationList(node.initializer)) {
+        return false;
+    }
+    const declList = node.initializer;
+    if (!(declList.flags & ts.NodeFlags.Const)) {
+        return false;
+    }
+    // Must have exactly one declaration
+    if (declList.declarations.length !== 1) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Extract full source path from an expression (e.g., data.memberEmails)
+ */
+function extractSourcePath(expr) {
+    if (ts.isIdentifier(expr)) {
+        return expr.text;
+    }
+    if (ts.isPropertyAccessExpression(expr)) {
+        const base = extractSourcePath(expr.expression);
+        if (base) {
+            return `${base}.${expr.name.text}`;
+        }
+    }
+    return null;
+}
+/**
+ * Extract the variable name from a for..of statement
+ */
+export function extractForOfVariable(node) {
+    if (!ts.isVariableDeclarationList(node.initializer)) {
+        return null;
+    }
+    const decl = node.initializer.declarations[0];
+    if (!ts.isIdentifier(decl.name)) {
+        return null;
+    }
+    const itemVar = decl.name.text;
+    // Extract source variable with full path (e.g., data.memberEmails)
+    const sourceVar = extractSourcePath(node.expression);
+    if (!sourceVar) {
+        return null;
+    }
+    return { itemVar, sourceVar };
+}
+/**
+ * Check if a type is an array type
+ */
+export function isArrayType(type, checker) {
+    // Check if it's an array type
+    if (checker.isArrayType(type)) {
+        return true;
+    }
+    // Check if it's a tuple type
+    if (type.flags & ts.TypeFlags.Object) {
+        const objectType = type;
+        if (objectType.objectFlags & ts.ObjectFlags.Tuple) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Get the source text of a node (for condition expressions)
+ */
+export function getSourceText(node) {
+    return node.getText().trim();
+}

package/dist/utils/workflow/dsl/validation.d.ts

@@ -0,0 +1,30 @@
+import * as ts from 'typescript';
+/**
+ * Validation rules for simple workflows
+ */
+export interface ValidationError {
+    message: string;
+    node: ts.Node;
+}
+/**
+ * Check if a node contains only allowed patterns
+ *
+ * Allowed patterns:
+ * - VariableStatement (const/let declarations)
+ * - ExpressionStatement (await workflow.do, await workflow.sleep, await Promise.all)
+ * - IfStatement (branches)
+ * - SwitchStatement (switch/case)
+ * - ForOfStatement (sequential fanout)
+ * - ReturnStatement
+ * - ThrowStatement (for WorkflowCancelledException)
+ * - Block (containers)
+ */
+export declare function validateNoDisallowedPatterns(node: ts.Node): ValidationError[];
+/**
+ * Validate that all workflow.do calls are awaited
+ */
+export declare function validateAwaitedCalls(node: ts.Node): ValidationError[];
+/**
+ * Combine all validation errors into a single error message
+ */
+export declare function formatValidationErrors(errors: ValidationError[]): string;

package/dist/utils/workflow/dsl/validation.js

@@ -0,0 +1,142 @@
+import * as ts from 'typescript';
+/**
+ * Check if a node contains only allowed patterns
+ *
+ * Allowed patterns:
+ * - VariableStatement (const/let declarations)
+ * - ExpressionStatement (await workflow.do, await workflow.sleep, await Promise.all)
+ * - IfStatement (branches)
+ * - SwitchStatement (switch/case)
+ * - ForOfStatement (sequential fanout)
+ * - ReturnStatement
+ * - ThrowStatement (for WorkflowCancelledException)
+ * - Block (containers)
+ */
+export function validateNoDisallowedPatterns(node) {
+    const errors = [];
+    function visitBlock(block) {
+        for (const statement of block.statements) {
+            if (ts.isVariableStatement(statement) ||
+                ts.isExpressionStatement(statement) ||
+                ts.isIfStatement(statement) ||
+                ts.isSwitchStatement(statement) ||
+                ts.isForOfStatement(statement) ||
+                ts.isReturnStatement(statement) ||
+                ts.isThrowStatement(statement)) {
+                // Allowed statement type - recurse into it
+                visitNode(statement);
+            }
+            else {
+                // Unknown/disallowed statement type
+                const nodeType = ts.SyntaxKind[statement.kind];
+                errors.push({
+                    message: `Statement type '${nodeType}' is not allowed in simple workflows. Allowed: const/let, if/else, switch/case, for..of, return, throw, and workflow calls. If this should be supported, please report the node type: ${nodeType}`,
+                    node: statement,
+                });
+            }
+        }
+    }
+    function visitNode(node) {
+        // Disallow while and do-while
+        if (ts.isWhileStatement(node) || ts.isDoStatement(node)) {
+            errors.push({
+                message: 'while and do-while loops are not allowed in simple workflows',
+                node,
+            });
+            return;
+        }
+        // Disallow for and for-in loops
+        if (ts.isForInStatement(node) || ts.isForStatement(node)) {
+            errors.push({
+                message: 'for and for-in loops are not allowed in simple workflows. Use for-of instead.',
+                node,
+            });
+            return;
+        }
+        // Check for inline workflow.do
+        if (ts.isCallExpression(node)) {
+            if (ts.isPropertyAccessExpression(node.expression)) {
+                const propAccess = node.expression;
+                if (propAccess.name.text === 'do' &&
+                    ts.isIdentifier(propAccess.expression) &&
+                    propAccess.expression.text === 'workflow') {
+                    const secondArg = node.arguments[1];
+                    if (secondArg &&
+                        (ts.isArrowFunction(secondArg) ||
+                            ts.isFunctionExpression(secondArg))) {
+                        errors.push({
+                            message: 'Inline workflow.do with function argument is not allowed in simple workflows. Use RPC form instead.',
+                            node,
+                        });
+                        return;
+                    }
+                }
+            }
+        }
+        // Recurse into blocks
+        if (ts.isBlock(node)) {
+            visitBlock(node);
+        }
+        else {
+            ts.forEachChild(node, visitNode);
+        }
+    }
+    visitNode(node);
+    return errors;
+}
+/**
+ * Validate that all workflow.do calls are awaited
+ */
+export function validateAwaitedCalls(node) {
+    const errors = [];
+    function visit(node, parentIsAwait = false, insidePromiseAll = false) {
+        // Check if this is Promise.all(...) first, before checking for workflow calls
+        if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression)) {
+            const propAccess = node.expression;
+            if (propAccess.name.text === 'all' &&
+                ts.isIdentifier(propAccess.expression) &&
+                propAccess.expression.text === 'Promise') {
+                // console.log('[DEBUG] Found Promise.all, setting insidePromiseAll=true')
+                // Visit children with insidePromiseAll = true
+                ts.forEachChild(node, (child) => visit(child, parentIsAwait, true));
+                return;
+            }
+        }
+        // Now check for workflow calls
+        if (ts.isCallExpression(node)) {
+            if (ts.isPropertyAccessExpression(node.expression)) {
+                const propAccess = node.expression;
+                if ((propAccess.name.text === 'do' || propAccess.name.text === 'sleep') &&
+                    ts.isIdentifier(propAccess.expression) &&
+                    propAccess.expression.text === 'workflow') {
+                    if (!parentIsAwait && !insidePromiseAll) {
+                        errors.push({
+                            message: `workflow.${propAccess.name.text}() must be awaited`,
+                            node,
+                        });
+                    }
+                    return;
+                }
+            }
+        }
+        if (ts.isAwaitExpression(node)) {
+            // Visit the expression itself with parentIsAwait=true
+            visit(node.expression, true, insidePromiseAll);
+        }
+        else {
+            ts.forEachChild(node, (child) => visit(child, false, insidePromiseAll));
+        }
+    }
+    visit(node);
+    return errors;
+}
+/**
+ * Combine all validation errors into a single error message
+ */
+export function formatValidationErrors(errors) {
+    if (errors.length === 0) {
+        return '';
+    }
+    return errors.map((err) => `- ${err.message}`).join('\n');
+}

package/dist/utils/workflow/graph/convert-dsl-to-graph.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts DSL (Domain Specific Language) step-based format to graph node format
+ */
+import type { WorkflowsMeta } from '@pikku/core/workflow';
+import type { SerializedWorkflowGraph } from './workflow-graph.types.js';
+/**
+ * Convert a DSL workflow to graph format
+ */
+export declare function convertDslToGraph(workflowName: string, meta: WorkflowsMeta[string]): SerializedWorkflowGraph;
+/**
+ * Convert all DSL workflows to graph format
+ */
+export declare function convertAllDslToGraphs(workflowsMeta: WorkflowsMeta): Record<string, SerializedWorkflowGraph>;