@arcteninc/core 0.0.22 → 0.0.23

package/package.json

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

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

@@ -57,11 +57,136 @@ 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
+    if (ts.isIdentifier(node)) {
+      const varName = node.getText(sourceFile);
+      const varExpr = variableMap.get(varName);
+      if (varExpr) {
+        extractFromExpr(varExpr);
+      }
+      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 +207,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 +239,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));
                 }
               }
             }
@@ -512,7 +632,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)));