@forgehive/forge-cli 0.3.6 → 0.3.7

package/dist/utils/taskAnalysis.js

@@ -45,10 +45,26 @@ function generateHash(input) {
     }
     return Math.abs(hash).toString(36);
 }
-// TypeScript AST analysis function
-function extractTaskFingerprints(sourceCode, filePath) {
+// TypeScript AST analysis function with error collection
+function extractTaskFingerprintsWithErrors(sourceCode, filePath, errors) {
+    try {
+        return extractTaskFingerprintsInternal(sourceCode, filePath, errors);
+    }
+    catch (error) {
+        errors.push({
+            type: 'parsing',
+            message: error instanceof Error ? error.message : 'TypeScript parsing failed',
+            location: { file: filePath },
+            details: { error: error instanceof Error ? error.stack : String(error) }
+        });
+        return [];
+    }
+}
+// TypeScript AST analysis function with error collection
+function extractTaskFingerprintsInternal(sourceCode, filePath, errors) {
     const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
     const fingerprints = [];
+    const processedNodes = new Set(); // Track processed createTask nodes to prevent duplicates
     let schemaNode = null;
     let boundariesNode = null;
     // First pass: find schema and boundaries variable declarations
@@ -73,11 +89,14 @@ function extractTaskFingerprints(sourceCode, filePath) {
         if (ts.isCallExpression(node) &&
             ts.isIdentifier(node.expression) &&
             node.expression.text === 'createTask') {
-            const taskName = extractTaskName(node, sourceFile);
-            if (taskName) {
-                const fingerprint = analyzeCreateTaskCall(node, sourceFile, filePath, taskName, schemaNode, boundariesNode);
-                if (fingerprint) {
-                    fingerprints.push(fingerprint);
+            if (!processedNodes.has(node)) {
+                processedNodes.add(node);
+                const taskName = extractTaskName(node, sourceFile);
+                if (taskName) {
+                    const fingerprint = analyzeCreateTaskCall(node, sourceFile, filePath, taskName, schemaNode, boundariesNode, errors);
+                    if (fingerprint) {
+                        fingerprints.push(fingerprint);
+                    }
                 }
             }
         }
@@ -89,10 +108,13 @@ function extractTaskFingerprints(sourceCode, filePath) {
                     ts.isCallExpression(decl.initializer) &&
                     ts.isIdentifier(decl.initializer.expression) &&
                     decl.initializer.expression.text === 'createTask') {
-                    const taskName = ts.isIdentifier(decl.name) ? decl.name.text : 'unknown';
-                    const fingerprint = analyzeCreateTaskCall(decl.initializer, sourceFile, filePath, taskName, schemaNode, boundariesNode);
-                    if (fingerprint) {
-                        fingerprints.push(fingerprint);
+                    if (!processedNodes.has(decl.initializer)) {
+                        processedNodes.add(decl.initializer);
+                        const taskName = ts.isIdentifier(decl.name) ? decl.name.text : 'unknown';
+                        const fingerprint = analyzeCreateTaskCall(decl.initializer, sourceFile, filePath, taskName, schemaNode, boundariesNode, errors);
+                        if (fingerprint) {
+                            fingerprints.push(fingerprint);
+                        }
                     }
                 }
             });
@@ -115,44 +137,109 @@ function extractTaskName(node, _sourceFile) {
     }
     return null;
 }
-function analyzeCreateTaskCall(node, sourceFile, filePath, taskName, schemaNode = null, boundariesNode = null) {
+function analyzeCreateTaskCall(node, sourceFile, filePath, taskName, schemaNode = null, boundariesNode = null, errors = []) {
     try {
         const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
         const args = node.arguments;
-        // Use pre-found schema or fall back to argument analysis
+        // Analyze createTask({ schema, boundaries, fn }) structure
         let inputSchema = { type: 'object', properties: {} };
-        if (schemaNode) {
-            inputSchema = analyzeSchemaArg(schemaNode, sourceFile);
-        }
-        else if (args[0]) {
-            inputSchema = analyzeSchemaArg(args[0], sourceFile);
-        }
-        // Use pre-found boundaries or fall back to argument analysis - simplified to just names
         let boundaries = [];
-        if (boundariesNode) {
-            boundaries = analyzeBoundariesArg(boundariesNode, sourceFile);
-        }
-        else if (args[1]) {
-            boundaries = analyzeBoundariesArg(args[1], sourceFile);
+        let boundaryTypes = new Map();
+        if (args[0] && ts.isObjectLiteralExpression(args[0])) {
+            const schemaProperty = args[0].properties.find(prop => ts.isPropertyAssignment(prop) &&
+                ts.isIdentifier(prop.name) &&
+                prop.name.text === 'schema');
+            const boundariesProperty = args[0].properties.find(prop => ts.isPropertyAssignment(prop) &&
+                ts.isIdentifier(prop.name) &&
+                prop.name.text === 'boundaries');
+            if (schemaNode) {
+                try {
+                    inputSchema = analyzeSchemaArg(schemaNode, sourceFile);
+                }
+                catch (error) {
+                    errors.push({
+                        type: 'schema',
+                        message: error instanceof Error ? error.message : 'Schema analysis failed',
+                        location: { file: filePath, line: position.line + 1, column: position.character + 1 },
+                        details: { taskName, schemaSource: 'variable' }
+                    });
+                }
+            }
+            else if (schemaProperty && ts.isPropertyAssignment(schemaProperty)) {
+                try {
+                    inputSchema = analyzeSchemaArg(schemaProperty.initializer, sourceFile);
+                }
+                catch (error) {
+                    errors.push({
+                        type: 'schema',
+                        message: error instanceof Error ? error.message : 'Schema analysis failed',
+                        location: { file: filePath, line: position.line + 1, column: position.character + 1 },
+                        details: { taskName, schemaSource: 'property' }
+                    });
+                }
+            }
+            if (boundariesNode) {
+                try {
+                    const boundaryInfo = analyzeBoundariesWithTypes(boundariesNode, sourceFile);
+                    boundaries = boundaryInfo.boundaries;
+                    boundaryTypes = boundaryInfo.types;
+                }
+                catch (error) {
+                    errors.push({
+                        type: 'boundary',
+                        message: error instanceof Error ? error.message : 'Boundary analysis failed',
+                        location: { file: filePath, line: position.line + 1, column: position.character + 1 },
+                        details: { taskName, boundarySource: 'variable' }
+                    });
+                }
+            }
+            else if (boundariesProperty && ts.isPropertyAssignment(boundariesProperty)) {
+                try {
+                    const boundaryInfo = analyzeBoundariesWithTypes(boundariesProperty.initializer, sourceFile);
+                    boundaries = boundaryInfo.boundaries;
+                    boundaryTypes = boundaryInfo.types;
+                }
+                catch (error) {
+                    errors.push({
+                        type: 'boundary',
+                        message: error instanceof Error ? error.message : 'Boundary analysis failed',
+                        location: { file: filePath, line: position.line + 1, column: position.character + 1 },
+                        details: { taskName, boundarySource: 'property' }
+                    });
+                }
+            }
         }
         // Extract function output type with better detection
         let outputType = { type: 'unknown' };
-        const functionArg = args[2];
+        let functionArg;
+        // Extract function from createTask({ fn }) structure
+        if (args[0] && ts.isObjectLiteralExpression(args[0])) {
+            const fnProperty = args[0].properties.find(prop => ts.isPropertyAssignment(prop) &&
+                ts.isIdentifier(prop.name) &&
+                prop.name.text === 'fn');
+            if (fnProperty && ts.isPropertyAssignment(fnProperty)) {
+                functionArg = fnProperty.initializer;
+            }
+        }
         if (functionArg) {
             if (ts.isFunctionExpression(functionArg) || ts.isArrowFunction(functionArg)) {
+                // Collect errors from main task function
+                const mainFunctionErrors = analyzeMainTaskFunctionErrors(functionArg, sourceFile, taskName);
+                errors.push(...mainFunctionErrors);
                 // Better return type extraction
                 if (functionArg.type) {
                     const typeString = cleanTypeString(functionArg.type.getText(sourceFile));
                     outputType = { type: typeString };
                 }
                 else {
-                    // Try to infer from return statements with better object analysis
-                    outputType = inferDetailedReturnType(functionArg, sourceFile);
+                    // Try to infer from return statements with boundary type information
+                    outputType = inferDetailedReturnType(functionArg, sourceFile, boundaryTypes);
                 }
             }
         }
         // Generate hash from task signature
-        const hashInput = `${taskName}:${JSON.stringify(inputSchema)}:${JSON.stringify(boundaries)}`;
+        const boundaryNames = boundaries.map(b => b.name);
+        const hashInput = `${taskName}:${JSON.stringify(inputSchema)}:${JSON.stringify(boundaryNames)}`;
         const hash = generateHash(hashInput);
         return {
             name: taskName,
@@ -173,8 +260,35 @@ function analyzeCreateTaskCall(node, sourceFile, filePath, taskName, schemaNode
     }
 }
 // Enhanced return type inference with detailed object analysis
-function inferDetailedReturnType(func, _sourceFile) {
+function inferDetailedReturnType(func, sourceFile, boundaryTypes = new Map()) {
     let returnType = { type: 'unknown' };
+    // First, collect variable declarations and their types within the function
+    const variableTypes = new Map();
+    function collectVariableDeclarations(node) {
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+            const varName = node.name.text;
+            // Handle await expressions specially for boundary calls
+            if (ts.isAwaitExpression(node.initializer) &&
+                ts.isCallExpression(node.initializer.expression) &&
+                ts.isIdentifier(node.initializer.expression.expression)) {
+                const boundaryName = node.initializer.expression.expression.text;
+                const boundaryType = boundaryTypes.get(boundaryName);
+                if (boundaryType && typeof boundaryType === 'object') {
+                    // Store the detailed type information
+                    variableTypes.set(varName, boundaryType);
+                }
+                else {
+                    const varType = inferTypeFromExpression(node.initializer, sourceFile, variableTypes, boundaryTypes);
+                    variableTypes.set(varName, { type: varType });
+                }
+            }
+            else {
+                const varType = inferTypeFromExpression(node.initializer, sourceFile, variableTypes, boundaryTypes);
+                variableTypes.set(varName, { type: varType });
+            }
+        }
+        ts.forEachChild(node, collectVariableDeclarations);
+    }
     function visitReturnStatements(node) {
         if (ts.isReturnStatement(node) && node.expression) {
             if (ts.isObjectLiteralExpression(node.expression)) {
@@ -184,34 +298,67 @@ function inferDetailedReturnType(func, _sourceFile) {
                     if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
                         // Handle explicit property assignments: { propName: value }
                         const propName = prop.name.text;
-                        let propType = 'unknown';
-                        // Try to infer property type from the initializer
-                        if (ts.isStringLiteral(prop.initializer)) {
-                            propType = 'string';
-                        }
-                        else if (ts.isNumericLiteral(prop.initializer)) {
-                            propType = 'number';
-                        }
-                        else if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
-                            prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {
-                            propType = 'boolean';
+                        // Check if it's a property access like result1.result
+                        if (ts.isPropertyAccessExpression(prop.initializer)) {
+                            const baseExpr = prop.initializer.expression;
+                            const propertyName = prop.initializer.name.text;
+                            if (ts.isIdentifier(baseExpr)) {
+                                const baseVarType = variableTypes.get(baseExpr.text);
+                                if (baseVarType && typeof baseVarType === 'object' && baseVarType.properties) {
+                                    const propertyType = baseVarType.properties[propertyName];
+                                    if (propertyType) {
+                                        properties[propName] = propertyType;
+                                    }
+                                    else {
+                                        properties[propName] = { type: 'unknown' };
+                                    }
+                                }
+                                else {
+                                    properties[propName] = { type: 'unknown' };
+                                }
+                            }
+                            else {
+                                properties[propName] = { type: 'unknown' };
+                            }
                         }
-                        else if (ts.isIdentifier(prop.initializer)) {
-                            // Variable reference - try to infer from name
-                            const varName = prop.initializer.text;
-                            propType = inferTypeFromVariableName(varName);
+                        else {
+                            const propType = inferTypeFromExpression(prop.initializer, sourceFile, variableTypes, boundaryTypes);
+                            // Handle identifiers that might reference boundary call results
+                            if (ts.isIdentifier(prop.initializer)) {
+                                const varType = variableTypes.get(prop.initializer.text);
+                                if (varType && typeof varType === 'object' && varType.type) {
+                                    properties[propName] = { type: varType.type };
+                                }
+                                else {
+                                    properties[propName] = { type: propType };
+                                }
+                            }
+                            else {
+                                properties[propName] = { type: propType };
+                            }
                         }
-                        else if (ts.isPropertyAccessExpression(prop.initializer)) {
-                            // Property access like response.handler
-                            propType = 'unknown';
-                        }
-                        properties[propName] = { type: propType };
                     }
                     else if (ts.isShorthandPropertyAssignment(prop)) {
                         // Handle shorthand properties: { propName } (equivalent to { propName: propName })
                         const propName = prop.name.text;
-                        const propType = inferTypeFromVariableName(propName);
-                        properties[propName] = { type: propType };
+                        const varType = variableTypes.get(propName);
+                        if (varType && typeof varType === 'object' && varType.type) {
+                            // If we have detailed type information from boundary calls
+                            if (varType.type === 'object' && varType.properties) {
+                                properties[propName] = varType;
+                            }
+                            else if (varType.type === 'array' && varType.elementType) {
+                                // Handle arrays with elementType information
+                                properties[propName] = varType;
+                            }
+                            else {
+                                properties[propName] = { type: varType.type };
+                            }
+                        }
+                        else {
+                            const propType = varType ? (varType.type || 'unknown') : inferTypeFromIdentifier(prop.name.text, boundaryTypes);
+                            properties[propName] = { type: propType };
+                        }
                     }
                 });
                 if (Object.keys(properties).length > 0) {
@@ -236,43 +383,101 @@ function inferDetailedReturnType(func, _sourceFile) {
             }
             else if (ts.isIdentifier(node.expression)) {
                 // Single variable return
-                const varType = inferTypeFromVariableName(node.expression.text);
-                returnType = { type: varType };
+                const varType = variableTypes.get(node.expression.text);
+                if (varType) {
+                    returnType = varType;
+                }
+                else {
+                    const inferredType = inferTypeFromIdentifier(node.expression.text, boundaryTypes);
+                    returnType = { type: inferredType };
+                }
             }
         }
         ts.forEachChild(node, visitReturnStatements);
     }
     if (func.body) {
+        // First pass: collect variable declarations
+        collectVariableDeclarations(func.body);
+        // Second pass: analyze return statements
         visitReturnStatements(func.body);
     }
     return returnType;
 }
-// Helper function to infer types from variable names
-function inferTypeFromVariableName(varName) {
-    // Common patterns for type inference based on variable names
-    if (varName.includes('path') || varName.includes('Path') ||
-        varName.includes('name') || varName.includes('Name') ||
-        varName.includes('descriptor') || varName.includes('Descriptor') ||
-        varName.includes('fileName') || varName.includes('handler') ||
-        varName.includes('url') || varName.includes('id') ||
-        varName.includes('uuid') || varName.includes('token')) {
+// Helper function to infer type from any expression
+function inferTypeFromExpression(expr, sourceFile, variableTypes, boundaryTypes = new Map()) {
+    if (ts.isStringLiteral(expr)) {
         return 'string';
     }
-    else if (varName.includes('count') || varName.includes('Count') ||
-        varName.includes('size') || varName.includes('Size') ||
-        varName.includes('length') || varName.includes('Length') ||
-        varName.includes('index') || varName.includes('Index')) {
+    else if (ts.isNumericLiteral(expr)) {
         return 'number';
     }
-    else if (varName.includes('is') || varName.includes('has') ||
-        varName.includes('can') || varName.includes('should') ||
-        varName.includes('enabled') || varName.includes('success')) {
+    else if (expr.kind === ts.SyntaxKind.TrueKeyword || expr.kind === ts.SyntaxKind.FalseKeyword) {
         return 'boolean';
     }
-    else if (varName.includes('config') || varName.includes('Config') ||
-        varName.includes('options') || varName.includes('Options') ||
-        varName.includes('data') || varName.includes('result') ||
-        varName.includes('response') || varName.includes('error')) {
+    else if (ts.isArrayLiteralExpression(expr)) {
+        return 'array';
+    }
+    else if (ts.isObjectLiteralExpression(expr)) {
+        return 'object';
+    }
+    else if (ts.isIdentifier(expr)) {
+        // Check if we know the type from variable declarations
+        const varType = variableTypes.get(expr.text);
+        if (varType) {
+            return varType.type || 'unknown';
+        }
+        return inferTypeFromIdentifier(expr.text, boundaryTypes);
+    }
+    else if (ts.isCallExpression(expr)) {
+        // Handle method calls like array.reduce(), boundary calls, etc.
+        if (ts.isPropertyAccessExpression(expr.expression)) {
+            const methodName = expr.expression.name.text;
+            if (methodName === 'reduce') {
+                // For reduce, infer type from initial value (second argument)
+                if (expr.arguments.length > 1) {
+                    const initialValue = expr.arguments[1];
+                    return inferTypeFromExpression(initialValue, sourceFile, variableTypes, boundaryTypes);
+                }
+                return 'number'; // Common case for reduce operations
+            }
+            else if (methodName === 'map' || methodName === 'filter') {
+                // These typically return arrays
+                return 'array';
+            }
+            else if (methodName === 'join' || methodName === 'toString') {
+                // These return strings
+                return 'string';
+            }
+            else if (methodName === 'length' || methodName === 'indexOf' || methodName === 'findIndex') {
+                // These return numbers
+                return 'number';
+            }
+        }
+        else if (ts.isIdentifier(expr.expression)) {
+            // Direct function calls - could be boundary functions
+            const functionName = expr.expression.text;
+            const boundaryType = boundaryTypes.get(functionName);
+            if (boundaryType) {
+                // If boundaryType is an object with type info, return the type
+                if (typeof boundaryType === 'object' && boundaryType.type) {
+                    return boundaryType.type;
+                }
+                return typeof boundaryType === 'string' ? boundaryType : 'unknown';
+            }
+            return 'unknown';
+        }
+        return 'unknown';
+    }
+    else if (ts.isAwaitExpression(expr)) {
+        // Handle await expressions - analyze the awaited expression
+        return inferTypeFromExpression(expr.expression, sourceFile, variableTypes, boundaryTypes);
+    }
+    else if (ts.isPropertyAccessExpression(expr)) {
+        // Handle property access like obj.prop - try to infer from base object
+        const baseType = inferTypeFromExpression(expr.expression, sourceFile, variableTypes, boundaryTypes);
+        if (baseType === 'object') {
+            return 'unknown'; // Could be any property type
+        }
         return 'unknown';
     }
     return 'unknown';
@@ -310,29 +515,38 @@ function analyzeSchemaArg(node, sourceFile) {
     return { type: 'object', properties: {} };
 }
 // Enhanced schema property analysis
-function analyzeSchemaProp(node, _sourceFile) {
+function analyzeSchemaProp(node, sourceFile) {
     // Analyze Schema.string(), Schema.number(), etc.
     if (ts.isCallExpression(node)) {
         if (ts.isPropertyAccessExpression(node.expression) &&
             ts.isIdentifier(node.expression.expression) &&
             node.expression.expression.text === 'Schema') {
             const methodName = node.expression.name.text;
-            let baseType = { type: getSchemaTypeFromMethod(methodName) };
-            // Check for chained methods like .optional() or .default()
-            let current = node;
-            while (current.parent && ts.isCallExpression(current.parent)) {
-                current = current.parent;
-                if (ts.isPropertyAccessExpression(current.expression)) {
-                    const chainedMethod = current.expression.name.text;
-                    if (chainedMethod === 'optional') {
-                        baseType = { ...baseType, optional: true };
-                    }
-                    else if (chainedMethod === 'default' && current.arguments[0]) {
-                        baseType = { ...baseType, default: current.arguments[0].getText() };
-                    }
+            const baseType = { type: getSchemaTypeFromMethod(methodName) };
+            return baseType;
+        }
+    }
+    // Handle chained calls like Schema.number().optional()
+    if (ts.isCallExpression(node)) {
+        if (ts.isPropertyAccessExpression(node.expression)) {
+            const chainedMethod = node.expression.name.text;
+            if (chainedMethod === 'optional') {
+                // This is a .optional() call, get the base type
+                const baseCall = node.expression.expression;
+                if (ts.isCallExpression(baseCall)) {
+                    const baseType = analyzeSchemaProp(baseCall, sourceFile);
+                    return { ...baseType, optional: true };
+                }
+            }
+            else if (chainedMethod === 'default') {
+                // This is a .default() call, get the base type
+                const baseCall = node.expression.expression;
+                if (ts.isCallExpression(baseCall)) {
+                    const baseType = analyzeSchemaProp(baseCall, sourceFile);
+                    const defaultValue = node.arguments[0]?.getText() || 'undefined';
+                    return { ...baseType, default: defaultValue };
                 }
             }
-            return baseType;
         }
     }
     return { type: 'unknown' };
@@ -347,34 +561,473 @@ function getSchemaTypeFromMethod(methodName) {
     };
     return typeMap[methodName] || 'unknown';
 }
-function analyzeBoundariesArg(node, _sourceFile) {
+// Enhanced boundary analysis that extracts detailed boundary information
+function analyzeBoundariesWithTypes(node, sourceFile) {
+    const names = [];
+    const types = new Map();
     const boundaries = [];
-    // Handle variable references (e.g., when boundaries is defined as const boundaries = ...)
-    if (ts.isIdentifier(node) && node.text === 'boundaries') {
-        // This case is now handled by pre-finding the boundaries node
-        return [];
-    }
     if (ts.isObjectLiteralExpression(node)) {
         node.properties.forEach(prop => {
             if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
                 const boundaryName = prop.name.text;
-                boundaries.push(boundaryName);
+                names.push(boundaryName);
+                const boundaryErrors = [];
+                // Try to analyze the boundary function to extract input and output types
+                if (ts.isArrowFunction(prop.initializer) || ts.isFunctionExpression(prop.initializer)) {
+                    try {
+                        // Analyze input parameters with error collection
+                        const inputAnalysis = analyzeBoundaryInputTypesWithErrors(prop.initializer, sourceFile, boundaryName);
+                        boundaryErrors.push(...inputAnalysis.errors);
+                        // Analyze return type with error collection
+                        const returnAnalysis = analyzeBoundaryReturnTypeWithErrors(prop.initializer, sourceFile, boundaryName);
+                        boundaryErrors.push(...returnAnalysis.errors);
+                        types.set(boundaryName, returnAnalysis.returnType);
+                        // Validate boundary structure and collect structural errors
+                        const structuralErrors = validateBoundaryStructure(prop.initializer, sourceFile, boundaryName);
+                        boundaryErrors.push(...structuralErrors);
+                        // Create boundary fingerprint
+                        const boundaryFingerprint = {
+                            name: boundaryName,
+                            input: inputAnalysis.inputTypes,
+                            output: returnAnalysis.returnType,
+                            errors: boundaryErrors
+                        };
+                        boundaries.push(boundaryFingerprint);
+                    }
+                    catch (error) {
+                        boundaryErrors.push({
+                            type: 'boundary',
+                            message: error instanceof Error ? error.message : 'Boundary analysis failed',
+                            location: { file: sourceFile.fileName },
+                            details: { boundaryName, errorType: 'critical_analysis_failure' }
+                        });
+                        // Create boundary fingerprint with error
+                        const boundaryFingerprint = {
+                            name: boundaryName,
+                            input: [],
+                            output: { type: 'unknown' },
+                            errors: boundaryErrors
+                        };
+                        boundaries.push(boundaryFingerprint);
+                    }
+                }
+                else {
+                    // Not a function - this is an error
+                    boundaryErrors.push({
+                        type: 'boundary',
+                        message: 'Boundary is not a function',
+                        location: { file: sourceFile.fileName },
+                        details: { boundaryName, nodeType: ts.SyntaxKind[prop.initializer.kind] }
+                    });
+                    const boundaryFingerprint = {
+                        name: boundaryName,
+                        input: [],
+                        output: { type: 'unknown' },
+                        errors: boundaryErrors
+                    };
+                    boundaries.push(boundaryFingerprint);
+                }
             }
         });
     }
-    return boundaries;
+    return { names, types, boundaries };
+}
+// Analyze boundary function input parameter types with error collection
+function analyzeBoundaryInputTypesWithErrors(func, sourceFile, boundaryName) {
+    const inputTypes = [];
+    const errors = [];
+    if (func.parameters) {
+        func.parameters.forEach((param, index) => {
+            if (ts.isIdentifier(param.name)) {
+                const paramName = param.name.text;
+                if (param.type) {
+                    try {
+                        const typeText = param.type.getText(sourceFile);
+                        const schemaProperty = parseTypeToSchemaProperty(typeText);
+                        inputTypes.push({ ...schemaProperty, name: paramName });
+                    }
+                    catch (error) {
+                        errors.push({
+                            type: 'boundary',
+                            message: `Failed to parse parameter type for '${paramName}': ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            location: { file: sourceFile.fileName },
+                            details: { boundaryName, parameterName: paramName, parameterIndex: index }
+                        });
+                        inputTypes.push({ name: paramName, type: 'unknown' });
+                    }
+                }
+                else {
+                    // No type annotation - just use unknown
+                    inputTypes.push({ name: paramName, type: 'unknown' });
+                }
+            }
+            else {
+                // Complex parameter patterns (destructuring, etc.) - just use unknown
+                inputTypes.push({ name: `param${index}`, type: 'unknown' });
+            }
+        });
+        // Only check for obvious parameter issues
+        if (func.parameters.length === 0) {
+            errors.push({
+                type: 'boundary',
+                message: 'Boundary function has no parameters',
+                location: { file: sourceFile.fileName },
+                details: { boundaryName, issue: 'no_parameters' }
+            });
+        }
+    }
+    return { inputTypes, errors };
+}
+// Helper function to convert TypeScript type text to SchemaProperty
+function parseTypeToSchemaProperty(typeText) {
+    // Remove whitespace
+    const cleanType = typeText.trim();
+    if (cleanType === 'string') {
+        return { type: 'string' };
+    }
+    else if (cleanType === 'number') {
+        return { type: 'number' };
+    }
+    else if (cleanType === 'boolean') {
+        return { type: 'boolean' };
+    }
+    else if (cleanType.includes('[]') || cleanType.includes('Array<')) {
+        return { type: 'array' };
+    }
+    else if (cleanType.includes('{') && cleanType.includes('}')) {
+        // Parse object type structure
+        const objectMatch = cleanType.match(/^\s*\{\s*(.+)\s*\}\s*$/);
+        if (objectMatch) {
+            const properties = {};
+            const propsString = objectMatch[1];
+            // Split by commas and semicolons
+            const propPairs = propsString.split(/[,;]/).map(s => s.trim());
+            for (const propPair of propPairs) {
+                const colonIndex = propPair.indexOf(':');
+                if (colonIndex > 0) {
+                    const propName = propPair.substring(0, colonIndex).trim();
+                    const propType = propPair.substring(colonIndex + 1).trim();
+                    properties[propName] = parseTypeToSchemaProperty(propType);
+                }
+            }
+            return {
+                type: 'object',
+                properties
+            };
+        }
+        return { type: 'object' };
+    }
+    else {
+        return { type: cleanType };
+    }
+}
+// Helper function to infer type from variable names using TypeScript compiler analysis
+function inferTypeFromIdentifier(identifierText, boundaryTypes) {
+    // Check boundary types first
+    if (boundaryTypes.has(identifierText)) {
+        const boundaryType = boundaryTypes.get(identifierText);
+        if (typeof boundaryType === 'object' && boundaryType.type) {
+            return boundaryType.type;
+        }
+        return (typeof boundaryType === 'object' && boundaryType?.type) ? boundaryType.type : 'unknown';
+    }
+    // Use TypeScript's built-in type inference instead of hardcoded patterns
+    // For now, return unknown and let the compiler handle it
+    return 'unknown';
+}
+// Analyze boundary function return type with error collection
+function analyzeBoundaryReturnTypeWithErrors(func, sourceFile, boundaryName) {
+    const errors = [];
+    // Check if function has explicit return type annotation
+    if (func.type) {
+        try {
+            const typeText = func.type.getText(sourceFile);
+            // Handle Promise<T> types - extract T
+            const promiseMatch = typeText.match(/Promise<(.+)>/);
+            if (promiseMatch) {
+                const innerType = promiseMatch[1];
+                // Just process the type without validation
+                // Parse detailed type patterns
+                if (innerType.includes('[]') || innerType.includes('Array<')) {
+                    // Extract array element type
+                    let elementType = 'unknown';
+                    if (innerType.includes('[]')) {
+                        // Handle T[] format
+                        const elementTypeMatch = innerType.match(/^(.+)\[\]$/);
+                        if (elementTypeMatch) {
+                            const rawElementType = elementTypeMatch[1].trim();
+                            // Parse object element types
+                            if (rawElementType.includes('{') && rawElementType.includes('}')) {
+                                const objectType = parseObjectTypeFromString(rawElementType);
+                                if (objectType && objectType.properties) {
+                                    return {
+                                        returnType: {
+                                            type: 'array',
+                                            elementType: {
+                                                type: 'object',
+                                                properties: objectType.properties
+                                            }
+                                        },
+                                        errors
+                                    };
+                                }
+                            }
+                            elementType = rawElementType;
+                        }
+                    }
+                    else if (innerType.includes('Array<')) {
+                        // Handle Array<T> format
+                        const elementTypeMatch = innerType.match(/Array<(.+)>/);
+                        if (elementTypeMatch) {
+                            elementType = elementTypeMatch[1].trim();
+                        }
+                    }
+                    return {
+                        returnType: {
+                            type: 'array',
+                            elementType: elementType === 'unknown' ? undefined : { type: elementType }
+                        },
+                        errors
+                    };
+                }
+                else if (innerType === 'string') {
+                    return { returnType: { type: 'string' }, errors };
+                }
+                else if (innerType === 'number') {
+                    return { returnType: { type: 'number' }, errors };
+                }
+                else if (innerType === 'boolean') {
+                    return { returnType: { type: 'boolean' }, errors };
+                }
+                else if (innerType.includes('{') && innerType.includes('}')) {
+                    // Try to parse object type structure from string
+                    try {
+                        const parsedType = parseObjectTypeFromString(innerType);
+                        return { returnType: parsedType, errors };
+                    }
+                    catch (parseError) {
+                        errors.push({
+                            type: 'boundary',
+                            message: `Failed to parse return type object structure: ${parseError instanceof Error ? parseError.message : 'Unknown error'}`,
+                            location: { file: sourceFile.fileName },
+                            details: { boundaryName, returnType: innerType, issue: 'object_parse_failure' }
+                        });
+                        return { returnType: { type: 'object' }, errors };
+                    }
+                }
+            }
+            else {
+                // Not a Promise type - just use the type as-is
+            }
+            return { returnType: { type: cleanTypeString(typeText) }, errors };
+        }
+        catch (error) {
+            errors.push({
+                type: 'boundary',
+                message: `Failed to analyze return type: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                location: { file: sourceFile.fileName },
+                details: { boundaryName, issue: 'return_type_analysis_failure' }
+            });
+            return { returnType: { type: 'unknown' }, errors };
+        }
+    }
+    else {
+        // No return type annotation - will try to infer
+    }
+    // If no explicit type, try to infer from return statements
+    if (func.body) {
+        try {
+            const returnType = inferDetailedReturnType(func, sourceFile, new Map());
+            return { returnType, errors };
+        }
+        catch (error) {
+            errors.push({
+                type: 'boundary',
+                message: `Failed to infer return type from function body: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                location: { file: sourceFile.fileName },
+                details: { boundaryName, issue: 'return_type_inference_failure' }
+            });
+        }
+    }
+    return { returnType: { type: 'unknown' }, errors };
+}
+// Helper function to check for throw statements in boundary functions
+function checkForBoundaryThrowStatements(node, sourceFile, errors) {
+    if (ts.isThrowStatement(node)) {
+        let errorMessage = 'Boundary function contains throw statement';
+        // Try to extract error message if it's a simple throw new Error('message')
+        if (node.expression && ts.isNewExpression(node.expression)) {
+            if (ts.isIdentifier(node.expression.expression) &&
+                node.expression.expression.text === 'Error' &&
+                node.expression.arguments &&
+                node.expression.arguments.length > 0) {
+                const errorArg = node.expression.arguments[0];
+                if (ts.isStringLiteral(errorArg)) {
+                    errorMessage = `Boundary function throws: ${errorArg.text}`;
+                }
+            }
+        }
+        const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        errors.push({
+            type: 'boundary',
+            message: errorMessage,
+            location: {
+                file: sourceFile.fileName,
+                line: position.line + 1,
+                column: position.character + 1
+            }
+        });
+    }
+    ts.forEachChild(node, (childNode) => checkForBoundaryThrowStatements(childNode, sourceFile, errors));
+}
+// Validate boundary structure and collect structural errors (simplified to focus on runtime errors)
+function validateBoundaryStructure(func, sourceFile, _boundaryName) {
+    const errors = [];
+    // Check function body for potential runtime errors
+    if (func.body) {
+        if (ts.isBlock(func.body)) {
+            checkForBoundaryThrowStatements(func.body, sourceFile, errors);
+        }
+    }
+    return errors;
+}
+// Helper function to check for throw statements in main task functions
+function checkForMainTaskThrowStatements(node, sourceFile, errors) {
+    if (ts.isThrowStatement(node)) {
+        let errorMessage = 'Main task function contains throw statement';
+        // Try to extract error message if it's a simple throw new Error('message')
+        if (node.expression && ts.isNewExpression(node.expression)) {
+            if (ts.isIdentifier(node.expression.expression) &&
+                node.expression.expression.text === 'Error' &&
+                node.expression.arguments &&
+                node.expression.arguments.length > 0) {
+                const errorArg = node.expression.arguments[0];
+                if (ts.isStringLiteral(errorArg)) {
+                    errorMessage = `Main task function throws: ${errorArg.text}`;
+                }
+                else if (ts.isTemplateExpression(errorArg)) {
+                    // Handle template literals like `User with ID ${userId} not found`
+                    const templateText = errorArg.getText(sourceFile);
+                    errorMessage = `Main task function throws: ${templateText.replace(/`/g, '')}`;
+                }
+            }
+        }
+        const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        errors.push({
+            type: 'analysis',
+            message: errorMessage,
+            location: {
+                file: sourceFile.fileName,
+                line: position.line + 1,
+                column: position.character + 1
+            }
+        });
+    }
+    ts.forEachChild(node, (childNode) => checkForMainTaskThrowStatements(childNode, sourceFile, errors));
+}
+// Analyze main task function for throw statements and runtime errors
+function analyzeMainTaskFunctionErrors(func, sourceFile, _taskName) {
+    const errors = [];
+    // Check function body for potential runtime errors
+    if (func.body) {
+        if (ts.isBlock(func.body)) {
+            checkForMainTaskThrowStatements(func.body, sourceFile, errors);
+        }
+    }
+    return errors;
+}
+// Helper function to parse object type structure from type string
+function parseObjectTypeFromString(typeString) {
+    // Simple parsing for common object patterns like "{ result: string }"
+    const objectMatch = typeString.match(/^\s*\{\s*(.+)\s*\}\s*$/);
+    if (objectMatch) {
+        const properties = {};
+        const propsString = objectMatch[1];
+        // Split by commas (simple approach - doesn't handle nested objects)
+        const propPairs = propsString.split(',').map(s => s.trim());
+        for (const propPair of propPairs) {
+            const colonIndex = propPair.indexOf(':');
+            if (colonIndex > 0) {
+                const propName = propPair.substring(0, colonIndex).trim();
+                const propType = propPair.substring(colonIndex + 1).trim();
+                if (propType === 'string') {
+                    properties[propName] = { type: 'string' };
+                }
+                else if (propType === 'number') {
+                    properties[propName] = { type: 'number' };
+                }
+                else if (propType === 'boolean') {
+                    properties[propName] = { type: 'boolean' };
+                }
+                else if (propType.includes('[]')) {
+                    properties[propName] = { type: 'array' };
+                }
+                else {
+                    properties[propName] = { type: propType };
+                }
+            }
+        }
+        return {
+            type: 'object',
+            properties
+        };
+    }
+    return { type: 'object' };
 }
 // Export the core analysis function for reuse
 function analyzeTaskFile(sourceCode, filePath, _expectedTaskName) {
-    const taskFingerprint = extractTaskFingerprints(sourceCode, filePath)[0];
-    if (!taskFingerprint) {
-        return null;
-    }
-    // Return simplified output without name, location, hash
-    return {
-        description: taskFingerprint.description,
-        inputSchema: taskFingerprint.inputSchema,
-        outputType: taskFingerprint.outputType,
-        boundaries: taskFingerprint.boundaries
+    const errors = [];
+    const analysisMetadata = {
+        timestamp: new Date().toISOString(),
+        filePath,
+        success: true,
+        analysisVersion: '1.0.0'
     };
+    try {
+        const taskFingerprints = extractTaskFingerprintsWithErrors(sourceCode, filePath, errors);
+        const taskFingerprint = taskFingerprints[0];
+        if (!taskFingerprint) {
+            errors.push({
+                type: 'analysis',
+                message: 'No task fingerprint found in file',
+                location: { file: filePath },
+                details: { reason: 'No createTask calls detected' }
+            });
+            analysisMetadata.success = false;
+            return {
+                description: undefined,
+                inputSchema: { type: 'object', properties: {} },
+                outputType: { type: 'unknown' },
+                boundaries: [],
+                errors,
+                analysisMetadata
+            };
+        }
+        // Return simplified output without name, location, hash
+        return {
+            description: taskFingerprint.description,
+            inputSchema: taskFingerprint.inputSchema,
+            outputType: taskFingerprint.outputType,
+            boundaries: taskFingerprint.boundaries,
+            errors,
+            analysisMetadata
+        };
+    }
+    catch (error) {
+        errors.push({
+            type: 'parsing',
+            message: error instanceof Error ? error.message : 'Unknown parsing error',
+            location: { file: filePath },
+            details: { error: error instanceof Error ? error.stack : String(error) }
+        });
+        analysisMetadata.success = false;
+        return {
+            description: undefined,
+            inputSchema: { type: 'object', properties: {} },
+            outputType: { type: 'unknown' },
+            boundaries: [],
+            errors,
+            analysisMetadata
+        };
+    }
 }