@arcteninc/core 0.0.62 → 0.0.63

package/package.json

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

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

@@ -102,6 +102,12 @@ function extractToolNamesFromExpression(
   function extractFromExpr(node: ts.Node): void {
     if (visited.has(node)) return;
     visited.add(node);
+    
+    // Handle type assertions: (expr as any)
+    if (ts.isAsExpression(node)) {
+      extractFromExpr(node.expression);
+      return;
+    }
 
     // Direct array literal: [tool1, tool2]
     if (ts.isArrayLiteralExpression(node)) {
@@ -132,9 +138,12 @@ function extractToolNamesFromExpression(
             // Try to resolve the module to find the actual function name
             const resolvedName = resolvePropertyAccess(element, sourceFile, program);
             const finalName = resolvedName || propName;
-            if (!toolNames.has(finalName)) {
-              toolNames.add(finalName);
-              toolOrder.push(finalName); // Preserve order
+            // Only add if it's a valid identifier name
+            if (finalName && finalName !== 'undefined' && finalName !== 'null' && finalName !== 'any') {
+              if (!toolNames.has(finalName)) {
+                toolNames.add(finalName);
+                toolOrder.push(finalName); // Preserve order
+              }
             }
           }
         } else if (ts.isElementAccessExpression(element)) {
@@ -189,9 +198,12 @@ function extractToolNamesFromExpression(
       // Try to resolve the module to find the actual function name
       const resolvedName = resolvePropertyAccess(node, sourceFile, program);
       const finalName = resolvedName || propName;
-      if (!toolNames.has(finalName)) {
-        toolNames.add(finalName);
-        toolOrder.push(finalName);
+      // Only add if it's a valid identifier name (not empty, not a keyword)
+      if (finalName && finalName !== 'undefined' && finalName !== 'null' && finalName !== 'any') {
+        if (!toolNames.has(finalName)) {
+          toolNames.add(finalName);
+          toolOrder.push(finalName);
+        }
       }
       return;
     }
@@ -315,6 +327,7 @@ function buildVariableMap(sourceFile: ts.SourceFile): Map<string, ts.Expression>
 
 /**
  * Extract tools from useMemo callback, handling both arrow functions and regular functions
+ * Also handles type assertions like `as any`
  */
 function extractToolsFromUseMemo(
   useMemoCall: ts.CallExpression,
@@ -325,34 +338,45 @@ function extractToolsFromUseMemo(
   
   const firstArg = useMemoCall.arguments[0];
   
+  function extractFromBody(body: ts.Expression | ts.Block): ts.Expression | null {
+    if (ts.isBlock(body)) {
+      // Block body: () => { return [...] }
+      for (const stmt of body.statements) {
+        if (ts.isReturnStatement(stmt) && stmt.expression) {
+          return unwrapTypeAssertion(stmt.expression);
+        }
+      }
+    } else {
+      // Expression body: () => [...]
+      return unwrapTypeAssertion(body);
+    }
+    return null;
+  }
+  
   // Arrow function: () => [...]
   if (ts.isArrowFunction(firstArg)) {
     if (firstArg.body) {
-      if (ts.isBlock(firstArg.body)) {
-        // Block body: () => { return [...] }
-        for (const stmt of firstArg.body.statements) {
-          if (ts.isReturnStatement(stmt) && stmt.expression) {
-            return stmt.expression;
-          }
-        }
-      } else {
-        // Expression body: () => [...]
-        return firstArg.body;
-      }
+      return extractFromBody(firstArg.body);
     }
   }
   // Regular function: function() { return [...] }
   else if (ts.isFunctionExpression(firstArg) && firstArg.body) {
-    for (const stmt of firstArg.body.statements) {
-      if (ts.isReturnStatement(stmt) && stmt.expression) {
-        return stmt.expression;
-      }
-    }
+    return extractFromBody(firstArg.body);
   }
   
   return null;
 }
 
+/**
+ * Unwrap type assertions like `as any`, `as ToolFunction[]`, etc.
+ */
+function unwrapTypeAssertion(expr: ts.Expression): ts.Expression {
+  if (ts.isAsExpression(expr)) {
+    return expr.expression;
+  }
+  return expr;
+}
+
 /**
  * Extract tool names from ArctenAgent or useAgent usage
  */