@arcteninc/core 0.0.23 → 0.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcteninc/core",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",

package/scripts/cli-extract-types-auto.ts

@@ -90,12 +90,18 @@ function extractToolNamesFromExpression(
       return;
     }
 
-    // Variable reference: toolsList
+    // Variable reference: toolsList or function name: generateReport
     if (ts.isIdentifier(node)) {
       const varName = node.getText(sourceFile);
       const varExpr = variableMap.get(varName);
       if (varExpr) {
         extractFromExpr(varExpr);
+      } else {
+        // If not in variableMap, it might be a function declaration name
+        // Add it directly as a tool name (findFunctionDefinition will find it later)
+        if (varName && varName !== 'undefined' && varName !== 'null') {
+          toolNames.add(varName);
+        }
       }
       return;
     }
@@ -275,16 +281,38 @@ function findFunctionDefinition(
   functionName: string,
   sourceFile: ts.SourceFile,
   program: ts.Program
-): { sourceFile: ts.SourceFile; node: ts.FunctionDeclaration } | null {
+): { sourceFile: ts.SourceFile; node: ts.FunctionDeclaration | ts.VariableDeclaration } | null {
   // First, check if it's defined in the current file
-  let foundNode: ts.FunctionDeclaration | null = null;
+  let foundNode: ts.FunctionDeclaration | ts.VariableDeclaration | null = null;
 
   function visitForDefinition(node: ts.Node) {
+    // Function declaration: function generateReport() {}
     if (ts.isFunctionDeclaration(node) && node.name) {
       if (node.name.getText(sourceFile) === functionName) {
         foundNode = node;
       }
     }
+    
+    // Variable declaration with arrow function: const addFilter = async () => {}
+    // or function expression: const addFilter = async function() {}
+    if (ts.isVariableStatement(node)) {
+      for (const declaration of node.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name)) {
+          const varName = declaration.name.getText(sourceFile);
+          if (varName === functionName && declaration.initializer) {
+            // Check if it's an arrow function or function expression
+            if (
+              ts.isArrowFunction(declaration.initializer) ||
+              ts.isFunctionExpression(declaration.initializer)
+            ) {
+              foundNode = declaration;
+              break;
+            }
+          }
+        }
+      }
+    }
+    
     if (!foundNode) {
       ts.forEachChild(node, visitForDefinition);
     }
@@ -502,16 +530,46 @@ function serializeType(
  * Extract metadata from a function
  */
 function extractFunctionMetadata(
-  node: ts.FunctionDeclaration,
+  node: ts.FunctionDeclaration | ts.VariableDeclaration,
   checker: ts.TypeChecker,
   sourceFile: ts.SourceFile
 ): FunctionMetadata | null {
-  if (!node.name) {
+  let functionNode: ts.FunctionDeclaration | ts.ArrowFunction | ts.FunctionExpression | null = null;
+  let functionName: string;
+
+  // Handle FunctionDeclaration: function generateReport() {}
+  if (ts.isFunctionDeclaration(node)) {
+    if (!node.name) {
+      return null;
+    }
+    functionNode = node;
+    functionName = node.name.getText(sourceFile);
+  }
+  // Handle VariableDeclaration: const addFilter = async () => {}
+  else if (ts.isVariableDeclaration(node)) {
+    if (!ts.isIdentifier(node.name)) {
+      return null;
+    }
+    functionName = node.name.getText(sourceFile);
+    
+    if (node.initializer) {
+      if (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer)) {
+        functionNode = node.initializer;
+      } else {
+        return null;
+      }
+    } else {
+      return null;
+    }
+  } else {
     return null;
   }
 
-  const functionName = node.name.getText(sourceFile);
+  if (!functionNode) {
+    return null;
+  }
 
+  // Extract JSDoc comments
   const jsDocTags = ts.getJSDocTags(node);
   const jsDocComments = ts.getJSDocCommentsAndTags(node);
 
@@ -538,9 +596,24 @@ function extractFunctionMetadata(
 
   const properties: Record<string, JsonSchemaProperty> = {};
   const required: string[] = [];
-  const isAsync = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) || false;
-
-  for (const param of node.parameters) {
+  
+  // Check if async - works for both function declarations and arrow functions
+  const isAsync = 
+    (ts.isFunctionDeclaration(node) && node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)) ||
+    (ts.isVariableDeclaration(node) && node.initializer && ts.isArrowFunction(node.initializer) && 
+     (node.initializer.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) || false)) ||
+    (ts.isVariableDeclaration(node) && node.initializer && ts.isFunctionExpression(node.initializer) &&
+     (node.initializer.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) || false)) ||
+    false;
+
+  // Extract parameters from the function node
+  const parameters = ts.isFunctionDeclaration(node) 
+    ? node.parameters 
+    : (ts.isArrowFunction(functionNode) || ts.isFunctionExpression(functionNode))
+      ? functionNode.parameters
+      : [];
+
+  for (const param of parameters) {
     const paramName = param.name.getText(sourceFile);
     const hasDefault = param.initializer !== undefined;
 
@@ -581,8 +654,16 @@ function extractFunctionMetadata(
   }
 
   let returnType = 'any';
-  if (node.type) {
+  if (ts.isFunctionDeclaration(node) && node.type) {
     returnType = node.type.getText(sourceFile);
+  } else if (
+    ts.isVariableDeclaration(node) && 
+    node.initializer && 
+    (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))
+  ) {
+    if (node.initializer.type) {
+      returnType = node.initializer.type.getText(sourceFile);
+    }
   }
 
   return {