@arcteninc/core 0.0.23 → 0.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcteninc/core",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -20,11 +20,12 @@
   },
   "sideEffects": false,
   "bin": {
-    "arcten-extract-types": "./scripts/cli-extract-types-auto.ts"
+    "arcten-extract-types": "./scripts/cli-extract-types-auto.js"
   },
   "files": [
     "dist",
-    "scripts/cli-extract-types-auto.ts"
+    "scripts/cli-extract-types-auto.ts",
+    "scripts/cli-extract-types-auto.js"
   ],
   "scripts": {
     "dev": "vite build --watch",

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

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+/**
+ * Wrapper script to run the TypeScript CLI with bun
+ * Works with both npm and bun
+ */
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join, resolve } from 'path';
+import { existsSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Path to the TypeScript script - resolve relative to this wrapper
+const tsScript = resolve(__dirname, 'cli-extract-types-auto.ts');
+
+// Check if bun is available
+function checkBun() {
+  return new Promise((resolve) => {
+    const bunCheck = spawn('bun', ['--version'], { stdio: 'ignore' });
+    bunCheck.on('close', (code) => {
+      resolve(code === 0);
+    });
+    bunCheck.on('error', () => {
+      resolve(false);
+    });
+  });
+}
+
+async function main() {
+  const hasBun = await checkBun();
+  
+  if (!hasBun) {
+    console.error('❌ Error: bun is required to run arcten-extract-types');
+    console.error('');
+    console.error('Please install bun:');
+    console.error('  curl -fsSL https://bun.sh/install | bash');
+    console.error('');
+    console.error('Or use bunx instead of npx:');
+    console.error('  bunx arcten-extract-types .');
+    process.exit(1);
+  }
+
+  if (!existsSync(tsScript)) {
+    console.error(`❌ Error: Script not found at ${tsScript}`);
+    process.exit(1);
+  }
+
+  // Run the TypeScript script with bun
+  const args = process.argv.slice(2);
+  const bunProcess = spawn('bun', [tsScript, ...args], {
+    stdio: 'inherit',
+    shell: true
+  });
+
+  bunProcess.on('close', (code) => {
+    process.exit(code || 0);
+  });
+
+  bunProcess.on('error', (err) => {
+    console.error('❌ Error running script:', err.message);
+    process.exit(1);
+  });
+}
+
+main();
+

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

@@ -78,11 +78,25 @@ function extractToolNamesFromExpression(
         if (ts.isSpreadElement(element)) {
           // Handle spread: [...someArray]
           extractFromExpr(element.expression);
+        } else if (ts.isArrowFunction(element) || ts.isFunctionExpression(element)) {
+          // Skip anonymous functions - they don't have names to extract
+          // Example: tools: [function getStatus() { ... }] - this should have a name
+          if (ts.isFunctionExpression(element) && element.name) {
+            toolNames.add(element.name.getText(sourceFile));
+          }
+          // For arrow functions without names, skip them
         } 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') {
+          // Skip if it looks like code (contains operators, semicolons, etc.)
+          if (simpleName && 
+              simpleName !== 'undefined' && 
+              simpleName !== 'null' &&
+              !simpleName.includes('?') &&
+              !simpleName.includes(';') &&
+              !simpleName.includes('=>') &&
+              simpleName.length < 100) {
             toolNames.add(simpleName);
           }
         }
@@ -90,12 +104,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 +295,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);
     }
@@ -301,9 +343,9 @@ function findFunctionDefinition(
 
   function visitForImports(node: ts.Node) {
     if (ts.isImportDeclaration(node)) {
-      const moduleSpecifier = node.moduleClause;
-      if (moduleSpecifier && ts.isImportClause(moduleSpecifier)) {
-        const namedBindings = moduleSpecifier.namedBindings;
+      const importClause = node.importClause;
+      if (importClause) {
+        const namedBindings = importClause.namedBindings;
         if (namedBindings && ts.isNamedImports(namedBindings)) {
           for (const element of namedBindings.elements) {
             const importedName = element.name.getText(sourceFile);
@@ -502,16 +544,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 +610,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 +668,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 {