@arcteninc/core 0.0.22 → 0.0.24

package/package.json

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

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

@@ -57,11 +57,142 @@ async function findToolUsageFiles(projectRoot: string): Promise<string[]> {
   return files;
 }
 
+/**
+ * Extract tool names from an expression (handles arrays, variables, useMemo, etc.)
+ */
+function extractToolNamesFromExpression(
+  expr: ts.Expression,
+  sourceFile: ts.SourceFile,
+  variableMap: Map<string, ts.Expression>
+): Set<string> {
+  const toolNames = new Set<string>();
+  const visited = new Set<ts.Node>();
+
+  function extractFromExpr(node: ts.Node): void {
+    if (visited.has(node)) return;
+    visited.add(node);
+
+    // Direct array literal: [tool1, tool2]
+    if (ts.isArrayLiteralExpression(node)) {
+      for (const element of node.elements) {
+        if (ts.isSpreadElement(element)) {
+          // Handle spread: [...someArray]
+          extractFromExpr(element.expression);
+        } else {
+          const name = element.getText(sourceFile).trim();
+          // Remove any object property access (e.g., tools.getOrders -> getOrders)
+          const simpleName = name.split('.').pop() || name;
+          if (simpleName && simpleName !== 'undefined' && simpleName !== 'null') {
+            toolNames.add(simpleName);
+          }
+        }
+      }
+      return;
+    }
+
+    // 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;
+    }
+
+    // Property access: wrappedTools.getRAGInfo
+    if (ts.isPropertyAccessExpression(node)) {
+      const propName = node.name.getText(sourceFile);
+      toolNames.add(propName);
+      return;
+    }
+
+    // useMemo(() => [...], [])
+    if (ts.isCallExpression(node)) {
+      const callExpr = node.expression;
+      if (ts.isIdentifier(callExpr)) {
+        const funcName = callExpr.getText(sourceFile);
+        if (funcName === 'useMemo' && node.arguments.length > 0) {
+          const firstArg = node.arguments[0];
+          // Arrow function: () => [...]
+          if (ts.isArrowFunction(firstArg) && firstArg.body) {
+            if (ts.isBlock(firstArg.body)) {
+              // Block body: () => { return [...] }
+              for (const stmt of firstArg.body.statements) {
+                if (ts.isReturnStatement(stmt) && stmt.expression) {
+                  extractFromExpr(stmt.expression);
+                }
+              }
+            } else {
+              // Expression body: () => [...]
+              extractFromExpr(firstArg.body);
+            }
+          }
+          // Regular function call: useMemo(fn, [])
+          else if (ts.isFunctionExpression(firstArg) || ts.isArrowFunction(firstArg)) {
+            // Can't easily extract from function body without more analysis
+          }
+        }
+      }
+      return;
+    }
+
+    // Parenthesized: (toolsList)
+    if (ts.isParenthesizedExpression(node)) {
+      extractFromExpr(node.expression);
+      return;
+    }
+  }
+
+  extractFromExpr(expr);
+  return toolNames;
+}
+
+/**
+ * Build a map of variable declarations in the file
+ */
+function buildVariableMap(sourceFile: ts.SourceFile): Map<string, ts.Expression> {
+  const variableMap = new Map<string, ts.Expression>();
+
+  function visit(node: ts.Node) {
+    // const toolsList = [...] or const { tools } = something
+    if (ts.isVariableStatement(node)) {
+      for (const declaration of node.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name)) {
+          const varName = declaration.name.getText(sourceFile);
+          if (declaration.initializer) {
+            variableMap.set(varName, declaration.initializer);
+          }
+        }
+        // Handle destructuring: const { tools } = something
+        else if (ts.isObjectBindingPattern(declaration.name)) {
+          // For now, skip destructuring - can be enhanced later
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+  return variableMap;
+}
+
 /**
  * Extract tool names from ArctenAgent or useAgent usage
  */
-function extractToolNamesFromFile(sourceFile: ts.SourceFile): ToolUsage[] {
+function extractToolNamesFromFile(
+  sourceFile: ts.SourceFile,
+  program?: ts.Program
+): ToolUsage[] {
   const usages: ToolUsage[] = [];
+  const variableMap = buildVariableMap(sourceFile);
 
   function visit(node: ts.Node) {
     // Check for <ArctenAgent tools={[...]} safeTools={[...]} />
@@ -82,13 +213,9 @@ function extractToolNamesFromFile(sourceFile: ts.SourceFile): ToolUsage[] {
             if (attrName === 'tools' || attrName === 'safeTools') {
               if (attr.initializer && ts.isJsxExpression(attr.initializer)) {
                 const expr = attr.initializer.expression;
-                if (expr && ts.isArrayLiteralExpression(expr)) {
-                  for (const element of expr.elements) {
-                    const name = element.getText(sourceFile).trim();
-                    // Remove any object property access (e.g., tools.getOrders -> getOrders)
-                    const simpleName = name.split('.').pop() || name;
-                    toolNames.add(simpleName);
-                  }
+                if (expr) {
+                  const extracted = extractToolNamesFromExpression(expr, sourceFile, variableMap);
+                  extracted.forEach(name => toolNames.add(name));
                 }
               }
             }
@@ -118,13 +245,12 @@ function extractToolNamesFromFile(sourceFile: ts.SourceFile): ToolUsage[] {
               if (ts.isPropertyAssignment(prop)) {
                 const propName = prop.name.getText(sourceFile);
                 if (propName === 'tools' || propName === 'safeTools') {
-                  if (ts.isArrayLiteralExpression(prop.initializer)) {
-                    for (const element of prop.initializer.elements) {
-                      const name = element.getText(sourceFile).trim();
-                      const simpleName = name.split('.').pop() || name;
-                      toolNames.add(simpleName);
-                    }
-                  }
+                  const extracted = extractToolNamesFromExpression(
+                    prop.initializer,
+                    sourceFile,
+                    variableMap
+                  );
+                  extracted.forEach(name => toolNames.add(name));
                 }
               }
             }
@@ -155,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);
     }
@@ -382,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);
 
@@ -418,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;
 
@@ -461,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 {
@@ -512,7 +713,7 @@ async function autoDiscoverAndExtract(projectRoot: string, outputPath: string) {
   for (const file of files) {
     const sourceFile = program.getSourceFile(file);
     if (sourceFile) {
-      const usages = extractToolNamesFromFile(sourceFile);
+      const usages = extractToolNamesFromFile(sourceFile, program);
       if (usages.length > 0) {
         allToolUsages.push(...usages);
         usages.forEach(u => u.toolNames.forEach(name => allToolNames.add(name)));