@bubblelab/bubble-runtime 0.1.14 → 0.1.16

package/dist/validation/lint-rules.js

@@ -0,0 +1,755 @@
+import ts from 'typescript';
+/**
+ * Registry that manages and executes all lint rules
+ */
+export class LintRuleRegistry {
+    rules = [];
+    /**
+     * Register a lint rule
+     */
+    register(rule) {
+        this.rules.push(rule);
+    }
+    /**
+     * Execute all registered rules on the given code
+     * Traverses AST once and shares context with all rules for efficiency
+     */
+    validateAll(sourceFile) {
+        // Parse AST once and create shared context
+        const context = parseLintRuleContext(sourceFile);
+        const errors = [];
+        for (const rule of this.rules) {
+            try {
+                const ruleErrors = rule.validate(context);
+                errors.push(...ruleErrors);
+            }
+            catch (error) {
+                // If a rule fails, log but don't stop other rules
+                console.error(`Error in lint rule ${rule.name}:`, error);
+            }
+        }
+        return errors;
+    }
+    /**
+     * Get all registered rule names
+     */
+    getRuleNames() {
+        return this.rules.map((r) => r.name);
+    }
+}
+/**
+ * Parses the AST once to create a shared context for all lint rules
+ * This avoids redundant AST traversals by doing a single pass
+ */
+function parseLintRuleContext(sourceFile) {
+    let bubbleFlowClass = null;
+    let handleMethod = null;
+    const importedBubbleClasses = new Set();
+    // Single AST traversal to collect all needed information
+    const visit = (node) => {
+        // Find BubbleFlow class
+        if (ts.isClassDeclaration(node) && !bubbleFlowClass) {
+            if (node.heritageClauses) {
+                for (const clause of node.heritageClauses) {
+                    if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
+                        for (const type of clause.types) {
+                            if (ts.isIdentifier(type.expression)) {
+                                if (type.expression.text === 'BubbleFlow') {
+                                    bubbleFlowClass = node;
+                                    // Find handle method in this class
+                                    if (node.members) {
+                                        for (const member of node.members) {
+                                            if (ts.isMethodDeclaration(member)) {
+                                                const name = member.name;
+                                                if (ts.isIdentifier(name) && name.text === 'handle') {
+                                                    handleMethod = member;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Collect imported bubble classes
+        if (ts.isImportDeclaration(node)) {
+            const moduleSpecifier = node.moduleSpecifier;
+            if (ts.isStringLiteral(moduleSpecifier) &&
+                (moduleSpecifier.text === '@bubblelab/bubble-core' ||
+                    moduleSpecifier.text === '@nodex/bubble-core')) {
+                if (node.importClause && node.importClause.namedBindings) {
+                    if (ts.isNamedImports(node.importClause.namedBindings)) {
+                        for (const element of node.importClause.namedBindings.elements) {
+                            const importedName = element.name
+                                ? element.name.text
+                                : element.propertyName?.text;
+                            if (importedName) {
+                                if ((importedName.endsWith('Bubble') ||
+                                    (importedName.endsWith('Tool') &&
+                                        !importedName.includes('Structured'))) &&
+                                    importedName !== 'BubbleFlow' &&
+                                    importedName !== 'BaseBubble') {
+                                    importedBubbleClasses.add(importedName);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    let handleMethodBody = null;
+    if (handleMethod !== null) {
+        const methodBody = handleMethod.body;
+        if (methodBody !== undefined && ts.isBlock(methodBody)) {
+            handleMethodBody = methodBody;
+        }
+    }
+    return {
+        sourceFile,
+        bubbleFlowClass,
+        handleMethod,
+        handleMethodBody,
+        importedBubbleClasses,
+    };
+}
+/**
+ * Lint rule that prevents throw statements directly in the handle method
+ */
+export const noThrowInHandleRule = {
+    name: 'no-throw-in-handle',
+    validate(context) {
+        const errors = [];
+        // Use pre-parsed context
+        if (!context.handleMethodBody) {
+            return errors; // No handle method body found, skip this rule
+        }
+        // Check only direct statements in the method body (not nested)
+        for (const statement of context.handleMethodBody.statements) {
+            const throwError = checkStatementForThrow(statement, context.sourceFile);
+            if (throwError) {
+                errors.push(throwError);
+            }
+        }
+        return errors;
+    },
+};
+/**
+ * Checks if a statement is a throw statement or contains a throw at the top level
+ * Only checks direct statements, not nested blocks
+ */
+function checkStatementForThrow(statement, sourceFile) {
+    // Direct throw statement
+    if (ts.isThrowStatement(statement)) {
+        const { line } = sourceFile.getLineAndCharacterOfPosition(statement.getStart(sourceFile));
+        return {
+            line: line + 1, // Convert to 1-based
+            message: 'throw statements are not allowed directly in handle method. Move error handling into another step.',
+        };
+    }
+    // Check for if statement with direct throw in then/else branches
+    // Note: We only check if the then/else is a direct throw statement, not if it's inside a block
+    if (ts.isIfStatement(statement)) {
+        // Check if the then branch is a direct throw statement (not inside a block)
+        if (ts.isThrowStatement(statement.thenStatement)) {
+            const { line } = sourceFile.getLineAndCharacterOfPosition(statement.thenStatement.getStart(sourceFile));
+            return {
+                line: line + 1,
+                message: 'throw statements are not allowed directly in handle method. Move error handling into another step.',
+            };
+        }
+        // Check if the else branch is a direct throw statement (not inside a block)
+        if (statement.elseStatement &&
+            ts.isThrowStatement(statement.elseStatement)) {
+            const { line } = sourceFile.getLineAndCharacterOfPosition(statement.elseStatement.getStart(sourceFile));
+            return {
+                line: line + 1,
+                message: 'throw statements are not allowed directly in handle method. Move error handling into another step.',
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Lint rule that prevents direct bubble instantiation in the handle method
+ */
+export const noDirectBubbleInstantiationInHandleRule = {
+    name: 'no-direct-bubble-instantiation-in-handle',
+    validate(context) {
+        const errors = [];
+        // Use pre-parsed context
+        if (!context.handleMethodBody) {
+            return errors; // No handle method body found, skip this rule
+        }
+        // Recursively check all statements in the method body, including nested blocks
+        for (const statement of context.handleMethodBody.statements) {
+            const bubbleErrors = checkStatementForBubbleInstantiation(statement, context.sourceFile, context.importedBubbleClasses);
+            errors.push(...bubbleErrors);
+        }
+        return errors;
+    },
+};
+/**
+ * Checks if a statement contains a direct bubble instantiation
+ * Recursively checks nested blocks to find all bubble instantiations
+ */
+function checkStatementForBubbleInstantiation(statement, sourceFile, importedBubbleClasses) {
+    const errors = [];
+    // Check for variable declaration with bubble instantiation
+    if (ts.isVariableStatement(statement)) {
+        for (const declaration of statement.declarationList.declarations) {
+            if (declaration.initializer) {
+                const error = checkExpressionForBubbleInstantiation(declaration.initializer, sourceFile, importedBubbleClasses);
+                if (error) {
+                    errors.push(error);
+                }
+            }
+        }
+    }
+    // Check for expression statement with bubble instantiation
+    if (ts.isExpressionStatement(statement)) {
+        const error = checkExpressionForBubbleInstantiation(statement.expression, sourceFile, importedBubbleClasses);
+        if (error) {
+            errors.push(error);
+        }
+    }
+    // Check for if statement - recursively check then/else branches
+    if (ts.isIfStatement(statement)) {
+        // Check the then branch
+        if (ts.isBlock(statement.thenStatement)) {
+            // Recursively check all statements inside the block
+            for (const nestedStatement of statement.thenStatement.statements) {
+                const nestedErrors = checkStatementForBubbleInstantiation(nestedStatement, sourceFile, importedBubbleClasses);
+                errors.push(...nestedErrors);
+            }
+        }
+        else {
+            // Single statement (not a block) - check it directly
+            const nestedErrors = checkStatementForBubbleInstantiation(statement.thenStatement, sourceFile, importedBubbleClasses);
+            errors.push(...nestedErrors);
+        }
+        // Check the else branch if it exists
+        if (statement.elseStatement) {
+            if (ts.isBlock(statement.elseStatement)) {
+                // Recursively check all statements inside the block
+                for (const nestedStatement of statement.elseStatement.statements) {
+                    const nestedErrors = checkStatementForBubbleInstantiation(nestedStatement, sourceFile, importedBubbleClasses);
+                    errors.push(...nestedErrors);
+                }
+            }
+            else {
+                // Single statement (not a block) - check it directly
+                const nestedErrors = checkStatementForBubbleInstantiation(statement.elseStatement, sourceFile, importedBubbleClasses);
+                errors.push(...nestedErrors);
+            }
+        }
+    }
+    // Check for other block statements (for, while, etc.)
+    if (ts.isForStatement(statement) ||
+        ts.isWhileStatement(statement) ||
+        ts.isForInStatement(statement) ||
+        ts.isForOfStatement(statement)) {
+        const block = statement.statement;
+        if (ts.isBlock(block)) {
+            for (const nestedStatement of block.statements) {
+                const nestedErrors = checkStatementForBubbleInstantiation(nestedStatement, sourceFile, importedBubbleClasses);
+                errors.push(...nestedErrors);
+            }
+        }
+        else {
+            // Single statement (not a block) - check it directly
+            const nestedErrors = checkStatementForBubbleInstantiation(block, sourceFile, importedBubbleClasses);
+            errors.push(...nestedErrors);
+        }
+    }
+    // Check for try-catch-finally statements
+    if (ts.isTryStatement(statement)) {
+        // Check try block
+        if (ts.isBlock(statement.tryBlock)) {
+            for (const nestedStatement of statement.tryBlock.statements) {
+                const nestedErrors = checkStatementForBubbleInstantiation(nestedStatement, sourceFile, importedBubbleClasses);
+                errors.push(...nestedErrors);
+            }
+        }
+        // Check catch clause
+        if (statement.catchClause && statement.catchClause.block) {
+            for (const nestedStatement of statement.catchClause.block.statements) {
+                const nestedErrors = checkStatementForBubbleInstantiation(nestedStatement, sourceFile, importedBubbleClasses);
+                errors.push(...nestedErrors);
+            }
+        }
+        // Check finally block
+        if (statement.finallyBlock && ts.isBlock(statement.finallyBlock)) {
+            for (const nestedStatement of statement.finallyBlock.statements) {
+                const nestedErrors = checkStatementForBubbleInstantiation(nestedStatement, sourceFile, importedBubbleClasses);
+                errors.push(...nestedErrors);
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Checks if an expression is a bubble instantiation (new BubbleClass(...))
+ */
+function checkExpressionForBubbleInstantiation(expression, sourceFile, importedBubbleClasses) {
+    // Handle await expressions
+    if (ts.isAwaitExpression(expression)) {
+        return checkExpressionForBubbleInstantiation(expression.expression, sourceFile, importedBubbleClasses);
+    }
+    // Handle call expressions (e.g., new Bubble().action())
+    if (ts.isCallExpression(expression)) {
+        if (ts.isPropertyAccessExpression(expression.expression)) {
+            return checkExpressionForBubbleInstantiation(expression.expression.expression, sourceFile, importedBubbleClasses);
+        }
+    }
+    // Check for new expression
+    if (ts.isNewExpression(expression)) {
+        const className = getClassNameFromExpression(expression.expression);
+        if (className && isBubbleClass(className, importedBubbleClasses)) {
+            const { line } = sourceFile.getLineAndCharacterOfPosition(expression.getStart(sourceFile));
+            return {
+                line: line + 1,
+                message: 'Direct bubble instantiation is not allowed in handle method. Move bubble creation into another step.',
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Gets the class name from an expression (handles identifiers and property access)
+ */
+function getClassNameFromExpression(expression) {
+    if (ts.isIdentifier(expression)) {
+        return expression.text;
+    }
+    if (ts.isPropertyAccessExpression(expression)) {
+        return expression.name.text;
+    }
+    return null;
+}
+/**
+ * Checks if a class name represents a bubble class
+ */
+function isBubbleClass(className, importedBubbleClasses) {
+    // Check if it's in the imported bubble classes
+    if (importedBubbleClasses.has(className)) {
+        return true;
+    }
+    // Fallback: check naming pattern
+    // Bubble classes typically end with "Bubble" or "Tool" (but not StructuredTool)
+    const endsWithBubble = className.endsWith('Bubble');
+    const endsWithTool = className.endsWith('Tool') && !className.includes('Structured');
+    return ((endsWithBubble || endsWithTool) &&
+        className !== 'BubbleFlow' &&
+        className !== 'BaseBubble' &&
+        !className.includes('Error') &&
+        !className.includes('Exception') &&
+        !className.includes('Validation'));
+}
+/**
+ * Lint rule that prevents credentials parameter from being used in bubble instantiations
+ */
+export const noCredentialsParameterRule = {
+    name: 'no-credentials-parameter',
+    validate(context) {
+        const errors = [];
+        // Traverse entire source file to find all bubble instantiations
+        const visit = (node) => {
+            // Check for new expressions (bubble instantiations)
+            if (ts.isNewExpression(node)) {
+                const className = getClassNameFromExpression(node.expression);
+                if (className &&
+                    isBubbleClass(className, context.importedBubbleClasses)) {
+                    // Check constructor arguments for credentials parameter
+                    if (node.arguments && node.arguments.length > 0) {
+                        for (const arg of node.arguments) {
+                            const credentialError = checkForCredentialsParameter(arg, context.sourceFile);
+                            if (credentialError) {
+                                errors.push(credentialError);
+                            }
+                        }
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(context.sourceFile);
+        return errors;
+    },
+};
+/**
+ * Checks if an expression (constructor argument) contains a credentials parameter
+ */
+function checkForCredentialsParameter(expression, sourceFile) {
+    // Handle object literals: { credentials: {...} }
+    if (ts.isObjectLiteralExpression(expression)) {
+        for (const property of expression.properties) {
+            if (ts.isPropertyAssignment(property)) {
+                const name = property.name;
+                if ((ts.isIdentifier(name) && name.text === 'credentials') ||
+                    (ts.isStringLiteral(name) && name.text === 'credentials')) {
+                    const { line } = sourceFile.getLineAndCharacterOfPosition(property.getStart(sourceFile));
+                    return {
+                        line: line + 1,
+                        message: 'credentials parameter is not allowed in bubble instantiation. Credentials should be injected at runtime, not passed as parameters.',
+                    };
+                }
+            }
+            // Handle shorthand property: { credentials }
+            if (ts.isShorthandPropertyAssignment(property)) {
+                const name = property.name;
+                if (ts.isIdentifier(name) && name.text === 'credentials') {
+                    const { line } = sourceFile.getLineAndCharacterOfPosition(property.getStart(sourceFile));
+                    return {
+                        line: line + 1,
+                        message: 'credentials parameter is not allowed in bubble instantiation. Credentials should be injected at runtime, not passed as parameters.',
+                    };
+                }
+            }
+        }
+    }
+    // Handle spread expressions that might contain credentials
+    if (ts.isSpreadElement(expression)) {
+        return checkForCredentialsParameter(expression.expression, sourceFile);
+    }
+    // Handle type assertions: { credentials: {...} } as Record<string, string>
+    if (ts.isAsExpression(expression)) {
+        return checkForCredentialsParameter(expression.expression, sourceFile);
+    }
+    // Handle parenthesized expressions: ({ credentials: {...} })
+    if (ts.isParenthesizedExpression(expression)) {
+        return checkForCredentialsParameter(expression.expression, sourceFile);
+    }
+    return null;
+}
+/**
+ * Lint rule that prevents usage of process.env
+ */
+export const noProcessEnvRule = {
+    name: 'no-process-env',
+    validate(context) {
+        const errors = [];
+        // Traverse entire source file to find all process.env usages
+        const visit = (node) => {
+            // Check for property access expression: process.env
+            if (ts.isPropertyAccessExpression(node)) {
+                const object = node.expression;
+                const property = node.name;
+                // Check if it's process.env
+                if (ts.isIdentifier(object) &&
+                    object.text === 'process' &&
+                    ts.isIdentifier(property) &&
+                    property.text === 'env') {
+                    const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(node.getStart(context.sourceFile));
+                    errors.push({
+                        line: line + 1,
+                        column: character + 1,
+                        message: 'process.env is not allowed. Put the credential inside payload if the integration is not supported yet (service is not an available bubble).',
+                    });
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(context.sourceFile);
+        return errors;
+    },
+};
+/**
+ * Lint rule that prevents method invocations inside complex expressions
+ */
+export const noMethodInvocationInComplexExpressionRule = {
+    name: 'no-method-invocation-in-complex-expression',
+    validate(context) {
+        const errors = [];
+        // Track parent nodes to detect complex expressions
+        const visitWithParents = (node, parents = []) => {
+            // Check for method calls: this.methodName()
+            if (ts.isCallExpression(node)) {
+                if (ts.isPropertyAccessExpression(node.expression)) {
+                    const object = node.expression.expression;
+                    // Check if it's 'this' keyword (SyntaxKind.ThisKeyword)
+                    if (object.kind === ts.SyntaxKind.ThisKeyword) {
+                        // This is a method invocation: this.methodName()
+                        // Check if any parent is a complex expression
+                        const complexParent = findComplexExpressionParent(parents, node);
+                        if (complexParent) {
+                            const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(node.getStart(context.sourceFile));
+                            const methodName = node.expression.name.text;
+                            const parentType = getReadableParentType(complexParent);
+                            errors.push({
+                                line: line + 1,
+                                column: character + 1,
+                                message: `Method invocation 'this.${methodName}()' inside ${parentType} cannot be instrumented. Extract to a separate variable before using in ${parentType}.`,
+                            });
+                        }
+                    }
+                }
+            }
+            // Recursively visit children with updated parent chain
+            ts.forEachChild(node, (child) => {
+                visitWithParents(child, [...parents, node]);
+            });
+        };
+        visitWithParents(context.sourceFile);
+        return errors;
+    },
+};
+/**
+ * Finds if any parent node is a complex expression that cannot contain instrumented calls
+ */
+function findComplexExpressionParent(parents, node) {
+    // Walk through parents to find complex expressions
+    // Stop at statement boundaries (these are safe)
+    let currentChild = node;
+    for (let i = parents.length - 1; i >= 0; i--) {
+        const parent = parents[i];
+        // Stop at statement boundaries - these are safe contexts
+        if (ts.isVariableDeclaration(parent) ||
+            ts.isExpressionStatement(parent) ||
+            ts.isReturnStatement(parent) ||
+            ts.isBlock(parent)) {
+            return null;
+        }
+        // Check for complex expressions
+        if (ts.isConditionalExpression(parent)) {
+            return parent; // Ternary operator
+        }
+        if (ts.isObjectLiteralExpression(parent)) {
+            return parent; // Object literal
+        }
+        if (ts.isArrayLiteralExpression(parent)) {
+            if (currentChild &&
+                isPromiseAllArrayElement(parent, currentChild)) {
+                currentChild = parent;
+                continue;
+            }
+            return parent; // Array literal
+        }
+        if (ts.isPropertyAssignment(parent)) {
+            return parent; // Object property value
+        }
+        if (ts.isSpreadElement(parent)) {
+            return parent; // Spread expression
+        }
+        currentChild = parent;
+    }
+    return null;
+}
+/**
+ * Gets a human-readable description of the parent node type
+ */
+function getReadableParentType(node) {
+    if (ts.isConditionalExpression(node)) {
+        return 'ternary operator';
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        return 'object literal';
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        return 'array literal';
+    }
+    if (ts.isPropertyAssignment(node)) {
+        return 'object property';
+    }
+    if (ts.isSpreadElement(node)) {
+        return 'spread expression';
+    }
+    return 'complex expression';
+}
+function isPromiseAllArrayElement(arrayNode, childNode) {
+    if (!arrayNode.elements.some((element) => element === childNode)) {
+        return false;
+    }
+    if (!arrayNode.parent || !ts.isCallExpression(arrayNode.parent)) {
+        return false;
+    }
+    const callExpr = arrayNode.parent;
+    const callee = callExpr.expression;
+    if (!ts.isPropertyAccessExpression(callee) ||
+        !ts.isIdentifier(callee.expression) ||
+        callee.expression.text !== 'Promise' ||
+        callee.name.text !== 'all') {
+        return false;
+    }
+    return callExpr.arguments.length > 0 && callExpr.arguments[0] === arrayNode;
+}
+/**
+ * Lint rule that prevents try-catch statements in the handle method
+ * Try-catch blocks interfere with runtime instrumentation and error handling
+ */
+export const noTryCatchInHandleRule = {
+    name: 'no-try-catch-in-handle',
+    validate(context) {
+        const errors = [];
+        if (!context.handleMethodBody) {
+            return errors; // No handle method body found, skip this rule
+        }
+        // Recursively find all try statements in the handle method body
+        const findTryStatements = (node) => {
+            if (ts.isTryStatement(node)) {
+                const { line } = context.sourceFile.getLineAndCharacterOfPosition(node.getStart(context.sourceFile));
+                errors.push({
+                    line: line + 1,
+                    message: 'try-catch statements are not allowed in handle method. Error handling should be done in function steps.',
+                });
+                // Don't return early - continue checking nested content for multiple violations
+            }
+            ts.forEachChild(node, findTryStatements);
+        };
+        // Start recursive search from the handle method body
+        findTryStatements(context.handleMethodBody);
+        return errors;
+    },
+};
+/**
+ * Lint rule that prevents methods from calling other methods
+ * Methods should only be called from the handle method, not from other methods
+ */
+export const noMethodCallingMethodRule = {
+    name: 'no-method-calling-method',
+    validate(context) {
+        const errors = [];
+        if (!context.bubbleFlowClass) {
+            return errors; // No BubbleFlow class found, skip this rule
+        }
+        // Find all methods in the BubbleFlow class
+        const methods = [];
+        if (context.bubbleFlowClass.members) {
+            for (const member of context.bubbleFlowClass.members) {
+                if (ts.isMethodDeclaration(member)) {
+                    // Skip the handle method - it's allowed to call other methods
+                    const methodName = member.name;
+                    if (ts.isIdentifier(methodName) && methodName.text === 'handle') {
+                        continue;
+                    }
+                    methods.push(member);
+                }
+            }
+        }
+        // For each method, check if it calls other methods
+        for (const method of methods) {
+            if (!method.body || !ts.isBlock(method.body)) {
+                continue;
+            }
+            const methodCallErrors = findMethodCallsInNode(method.body, context.sourceFile);
+            errors.push(...methodCallErrors);
+        }
+        return errors;
+    },
+};
+/**
+ * Recursively finds all method calls (this.methodName()) in a node
+ */
+function findMethodCallsInNode(node, sourceFile) {
+    const errors = [];
+    const visit = (n) => {
+        // Check for call expressions: this.methodName()
+        if (ts.isCallExpression(n)) {
+            if (ts.isPropertyAccessExpression(n.expression)) {
+                const object = n.expression.expression;
+                // Check if it's 'this' keyword (SyntaxKind.ThisKeyword)
+                if (object.kind === ts.SyntaxKind.ThisKeyword) {
+                    const methodName = n.expression.name.text;
+                    const { line, character } = sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile));
+                    errors.push({
+                        line: line + 1,
+                        column: character + 1,
+                        message: `Method 'this.${methodName}()' cannot be called from another method. Methods should only be called from the handle method.`,
+                    });
+                }
+            }
+        }
+        ts.forEachChild(n, visit);
+    };
+    visit(node);
+    return errors;
+}
+/**
+ * Lint rule that prevents usage of 'any' type
+ * Using 'any' bypasses TypeScript's type checking and should be avoided
+ */
+export const noAnyTypeRule = {
+    name: 'no-any-type',
+    validate(context) {
+        const errors = [];
+        const visit = (node) => {
+            // Check for 'any' keyword in type nodes
+            if (node.kind === ts.SyntaxKind.AnyKeyword) {
+                const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(node.getStart(context.sourceFile));
+                errors.push({
+                    line: line + 1,
+                    column: character + 1,
+                    message: "Type 'any' is not allowed. Use a specific type, 'unknown', or a generic type parameter instead.",
+                });
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(context.sourceFile);
+        return errors;
+    },
+};
+/**
+ * Lint rule that prevents multiple BubbleFlow classes in a single file
+ * Only one class extending BubbleFlow is allowed per file for proper runtime instrumentation
+ */
+export const singleBubbleFlowClassRule = {
+    name: 'single-bubbleflow-class',
+    validate(context) {
+        const errors = [];
+        const bubbleFlowClasses = [];
+        // Traverse the entire source file to find all BubbleFlow class declarations
+        const visit = (node) => {
+            if (ts.isClassDeclaration(node)) {
+                if (node.heritageClauses) {
+                    for (const clause of node.heritageClauses) {
+                        if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
+                            for (const type of clause.types) {
+                                if (ts.isIdentifier(type.expression)) {
+                                    if (type.expression.text === 'BubbleFlow') {
+                                        const { line } = context.sourceFile.getLineAndCharacterOfPosition(node.getStart(context.sourceFile));
+                                        const className = node.name?.text || 'Anonymous';
+                                        bubbleFlowClasses.push({ name: className, line: line + 1 });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(context.sourceFile);
+        // If more than one BubbleFlow class found, report errors for all except the first
+        if (bubbleFlowClasses.length > 1) {
+            for (let i = 1; i < bubbleFlowClasses.length; i++) {
+                const cls = bubbleFlowClasses[i];
+                errors.push({
+                    line: cls.line,
+                    message: `Multiple BubbleFlow classes are not allowed. Found '${cls.name}' but '${bubbleFlowClasses[0].name}' already extends BubbleFlow. Remove the additional class or combine the flows into a single class.`,
+                });
+            }
+        }
+        return errors;
+    },
+};
+/**
+ * Default registry instance with all rules registered
+ */
+export const defaultLintRuleRegistry = new LintRuleRegistry();
+defaultLintRuleRegistry.register(noThrowInHandleRule);
+defaultLintRuleRegistry.register(noDirectBubbleInstantiationInHandleRule);
+defaultLintRuleRegistry.register(noCredentialsParameterRule);
+defaultLintRuleRegistry.register(noMethodInvocationInComplexExpressionRule);
+defaultLintRuleRegistry.register(noProcessEnvRule);
+defaultLintRuleRegistry.register(noMethodCallingMethodRule);
+defaultLintRuleRegistry.register(noTryCatchInHandleRule);
+defaultLintRuleRegistry.register(noAnyTypeRule);
+defaultLintRuleRegistry.register(singleBubbleFlowClassRule);
+//# sourceMappingURL=lint-rules.js.map