@forgehive/forge-cli 0.2.13 → 0.3.0

package/dist/utils/taskAnalysis.js

@@ -0,0 +1,380 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeTaskFile = analyzeTaskFile;
+const ts = __importStar(require("typescript"));
+// Hash generation function
+function generateHash(input) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+        const char = input.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32-bit integer
+    }
+    return Math.abs(hash).toString(36);
+}
+// TypeScript AST analysis function
+function extractTaskFingerprints(sourceCode, filePath) {
+    const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
+    const fingerprints = [];
+    let schemaNode = null;
+    let boundariesNode = null;
+    // First pass: find schema and boundaries variable declarations
+    function findVariables(node) {
+        if (ts.isVariableStatement(node)) {
+            node.declarationList.declarations.forEach(decl => {
+                if (ts.isIdentifier(decl.name)) {
+                    if (decl.name.text === 'schema' && decl.initializer) {
+                        schemaNode = decl.initializer;
+                    }
+                    else if (decl.name.text === 'boundaries' && decl.initializer) {
+                        boundariesNode = decl.initializer;
+                    }
+                }
+            });
+        }
+        ts.forEachChild(node, findVariables);
+    }
+    // Second pass: find createTask calls
+    function findCreateTask(node) {
+        // Look for createTask calls
+        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);
+                }
+            }
+        }
+        // Look for exported createTask assignments
+        if (ts.isVariableStatement(node) && node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
+            node.declarationList.declarations.forEach(decl => {
+                if (ts.isVariableDeclaration(decl) &&
+                    decl.initializer &&
+                    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);
+                    }
+                }
+            });
+        }
+        ts.forEachChild(node, findCreateTask);
+    }
+    // Execute both passes
+    findVariables(sourceFile);
+    findCreateTask(sourceFile);
+    return fingerprints;
+}
+function extractTaskName(node, _sourceFile) {
+    // Try to find the task name from variable assignment or export
+    let parent = node.parent;
+    while (parent) {
+        if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+            return parent.name.text;
+        }
+        parent = parent.parent;
+    }
+    return null;
+}
+function analyzeCreateTaskCall(node, sourceFile, filePath, taskName, schemaNode = null, boundariesNode = null) {
+    try {
+        const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        const args = node.arguments;
+        // Use pre-found schema or fall back to argument analysis
+        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);
+        }
+        // Extract function output type with better detection
+        let outputType = { type: 'unknown' };
+        const functionArg = args[2];
+        if (functionArg) {
+            if (ts.isFunctionExpression(functionArg) || ts.isArrowFunction(functionArg)) {
+                // 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);
+                }
+            }
+        }
+        // Generate hash from task signature
+        const hashInput = `${taskName}:${JSON.stringify(inputSchema)}:${JSON.stringify(boundaries)}`;
+        const hash = generateHash(hashInput);
+        return {
+            name: taskName,
+            location: {
+                file: filePath,
+                line: position.line + 1,
+                column: position.character + 1
+            },
+            inputSchema,
+            outputType,
+            boundaries,
+            hash
+        };
+    }
+    catch (error) {
+        console.warn(`Failed to analyze createTask call for ${taskName}:`, error);
+        return null;
+    }
+}
+// Enhanced return type inference with detailed object analysis
+function inferDetailedReturnType(func, _sourceFile) {
+    let returnType = { type: 'unknown' };
+    function visitReturnStatements(node) {
+        if (ts.isReturnStatement(node) && node.expression) {
+            if (ts.isObjectLiteralExpression(node.expression)) {
+                // Analyze object literal properties
+                const properties = {};
+                node.expression.properties.forEach(prop => {
+                    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';
+                        }
+                        else if (ts.isIdentifier(prop.initializer)) {
+                            // Variable reference - try to infer from name
+                            const varName = prop.initializer.text;
+                            propType = inferTypeFromVariableName(varName);
+                        }
+                        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 };
+                    }
+                });
+                if (Object.keys(properties).length > 0) {
+                    returnType = {
+                        type: 'object',
+                        properties
+                    };
+                }
+                else {
+                    returnType = { type: 'object' };
+                }
+            }
+            else if (ts.isStringLiteral(node.expression)) {
+                returnType = { type: 'string' };
+            }
+            else if (ts.isNumericLiteral(node.expression)) {
+                returnType = { type: 'number' };
+            }
+            else if (node.expression.kind === ts.SyntaxKind.TrueKeyword ||
+                node.expression.kind === ts.SyntaxKind.FalseKeyword) {
+                returnType = { type: 'boolean' };
+            }
+            else if (ts.isIdentifier(node.expression)) {
+                // Single variable return
+                const varType = inferTypeFromVariableName(node.expression.text);
+                returnType = { type: varType };
+            }
+        }
+        ts.forEachChild(node, visitReturnStatements);
+    }
+    if (func.body) {
+        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')) {
+        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')) {
+        return 'number';
+    }
+    else if (varName.includes('is') || varName.includes('has') ||
+        varName.includes('can') || varName.includes('should') ||
+        varName.includes('enabled') || varName.includes('success')) {
+        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')) {
+        return 'unknown';
+    }
+    return 'unknown';
+}
+// Clean up type strings (remove Promise wrappers for boundaries)
+function cleanTypeString(typeString) {
+    // Remove Promise wrapper for boundary functions
+    const promiseMatch = typeString.match(/Promise<(.+)>/);
+    if (promiseMatch) {
+        return promiseMatch[1];
+    }
+    return typeString;
+}
+function analyzeSchemaArg(node, sourceFile) {
+    // Handle variable references (e.g., when schema is defined as const schema = ...)
+    if (ts.isIdentifier(node) && node.text === 'schema') {
+        // This case is now handled by pre-finding the schema node
+        return { type: 'object', properties: {} };
+    }
+    // Handle direct Schema constructor calls
+    if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'Schema') {
+        const arg = node.arguments?.[0];
+        if (arg && ts.isObjectLiteralExpression(arg)) {
+            const properties = {};
+            arg.properties.forEach(prop => {
+                if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                    const propName = prop.name.text;
+                    const propValue = analyzeSchemaProp(prop.initializer, sourceFile);
+                    properties[propName] = propValue;
+                }
+            });
+            return { type: 'object', properties };
+        }
+    }
+    return { type: 'object', properties: {} };
+}
+// Enhanced schema property analysis
+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() };
+                    }
+                }
+            }
+            return baseType;
+        }
+    }
+    return { type: 'unknown' };
+}
+function getSchemaTypeFromMethod(methodName) {
+    const typeMap = {
+        string: 'string',
+        number: 'number',
+        boolean: 'boolean',
+        array: 'array',
+        object: 'object'
+    };
+    return typeMap[methodName] || 'unknown';
+}
+function analyzeBoundariesArg(node, _sourceFile) {
+    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);
+            }
+        });
+    }
+    return boundaries;
+}
+// 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
+    };
+}

package/forge.json

@@ -14,6 +14,10 @@
     "bucket": ""
   },
   "tasks": {
+    "task:createTask": {
+      "path": "src/tasks/task/createTask.ts",
+      "handler": "createTask"
+    },
     "bundle:create": {
       "path": "src/tasks/bundle/create.ts",
       "handler": "create"
@@ -89,6 +93,22 @@
     "bundle:zip": {
       "path": "src/tasks/bundle/zip.ts",
       "handler": "zip"
+    },
+    "task:list": {
+      "path": "src/tasks/task/list.ts",
+      "handler": "list"
+    },
+    "task:describe": {
+      "path": "src/tasks/task/describe.ts",
+      "handler": "describe"
+    },
+    "task:fingerprint": {
+      "path": "src/tasks/task/fingerprint.ts",
+      "handler": "fingerprint"
+    },
+    "bundle:fingerprint": {
+      "path": "src/tasks/bundle/fingerprint.ts",
+      "handler": "fingerprint"
     }
   },
   "runners": {}

package/jest.config.js

@@ -3,7 +3,8 @@ module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
   testMatch: ['**/*.test.ts'],
+  setupFilesAfterEnv: ['<rootDir>/src/test/setup.ts'],
   transform: {
     '^.+\\.tsx?$': 'ts-jest',
   },
-}; 
+};