@arcteninc/core 0.0.63 → 0.0.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcteninc/core",
-  "version": "0.0.63",
+  "version": "0.0.64",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -20,21 +20,19 @@
   },
   "sideEffects": false,
   "bin": {
-    "arcten": "./scripts/arcten-cli.cjs"
+    "arcten": "./scripts/arcten-cli.cjs",
+    "arcten-extract-types": "./scripts/cli-extract-types-auto-wrapper.js"
   },
   "files": [
     "dist",
     "scripts/cli-extract-types-auto.ts",
-    "scripts/cli-extract-types-auto.js",
-    "scripts/arcten-cli.cjs",
-    "scripts/postinstall-check-version.cjs",
-    "scripts/update-core.cjs"
+    "scripts/cli-extract-types-auto-wrapper.js",
+    "scripts/arcten-cli.cjs"
   ],
   "scripts": {
     "dev": "vite build --watch",
     "build": "vite build",
-    "prepublishOnly": "bun run build",
-    "postinstall": "node scripts/postinstall-check-version.cjs"
+    "prepublishOnly": "bun run build"
   },
   "peerDependencies": {
     "ai": "^6.0.0-beta.94",
@@ -56,6 +54,7 @@
   "dependencies": {
     "ts-json-schema-generator": "^2.4.0",
     "typescript": "^5.9.3",
+    "tsx": "^4.19.2",
     "@ai-sdk/openai": "^3.0.0-beta.47",
     "@ai-sdk/react": "^3.0.0-beta.92",
     "@emotion/is-prop-valid": "^1.4.0",

package/scripts/arcten-cli.cjs

@@ -14,9 +14,10 @@ const path = require('path');
 const fs = require('fs');
 
 const commands = {
-    'extract-types': () => require('./cli-extract-types-auto.js'),
-    'tools': () => require('./cli-extract-types-auto.js'), // Alias
-    'update': () => require('./update-core.js'),
+    'extract-types': 'extract-types',
+    'tools': 'extract-types', // Alias
+    'setup': 'extract-types', // Alias - better name for extract-types
+    'update': 'update',
     'help': showHelp,
     '--help': showHelp,
     '-h': showHelp,
@@ -29,18 +30,19 @@ function showHelp() {
 Usage: arcten <command> [options]
 
 Commands:
-  extract-types, tools    Extract tool metadata from your project
-                          Alias: arcten tools
+  extract-types, tools, setup    Extract tool metadata from your project
+                                  Aliases: arcten tools, arcten setup
   
-  update                  Update @arcteninc/core to latest version
-                          Updates package.json and shows next steps
+  update                          Update @arcteninc/core to latest version
+                                  Updates package.json and shows next steps
   
-  help                    Show this help message
+  help                            Show this help message
 
 Examples:
   arcten tools            Extract tool types (same as arcten extract-types)
-  arcten update           Update @arcteninc/core to latest version
-  arcten help             Show help
+  arcten setup             Extract tool types (same as arcten extract-types)
+  arcten update            Update @arcteninc/core to latest version
+  arcten help              Show help
 
 For more information, visit https://github.com/arcteninc/core
 `);
@@ -66,28 +68,26 @@ function main() {
 
     try {
         const commandHandler = commands[command];
-        if (typeof commandHandler === 'function' && commandHandler !== showHelp) {
-            // For commands that are modules, we need to handle them differently
-            // Since they're designed to run as standalone scripts, we'll spawn them
+
+        if (commandHandler === showHelp) {
+            // For help command
+            commandHandler();
+            return;
+        }
+
+        if (typeof commandHandler === 'string') {
+            // For commands that need to spawn scripts
             let scriptPath;
             let runner = 'node';
 
-            if (command === 'update') {
-                scriptPath = path.join(__dirname, 'update-core.cjs');
+            if (commandHandler === 'update') {
+                scriptPath = path.join(__dirname, 'update-core.js');
+            } else if (commandHandler === 'extract-types') {
+                // For extract-types/tools/setup, use the wrapper script which handles TypeScript execution
+                scriptPath = path.join(__dirname, 'cli-extract-types-auto-wrapper.js');
             } else {
-                // For extract-types/tools, try .js first, fallback to .ts with bun
-                const jsPath = path.join(__dirname, 'cli-extract-types-auto.js');
-                const tsPath = path.join(__dirname, 'cli-extract-types-auto.ts');
-
-                if (fs.existsSync(jsPath)) {
-                    scriptPath = jsPath;
-                } else if (fs.existsSync(tsPath)) {
-                    scriptPath = tsPath;
-                    runner = 'bun'; // Use bun for TypeScript files
-                } else {
-                    console.error(`❌ Script not found: ${jsPath} or ${tsPath}`);
-                    process.exit(1);
-                }
+                console.error(`❌ Unknown command handler: ${commandHandler}`);
+                process.exit(1);
             }
 
             if (!fs.existsSync(scriptPath)) {
@@ -106,7 +106,7 @@ function main() {
                 console.error(`❌ Failed to run command:`, error.message);
                 if (runner === 'bun' && error.code === 'ENOENT') {
                     console.error(`\n💡 Bun not found. Install it: https://bun.sh`);
-                    console.error(`   Or ensure cli-extract-types-auto.js is compiled`);
+                    console.error(`   Or ensure tsx is available: npm install -g tsx`);
                 }
                 process.exit(1);
             });
@@ -115,8 +115,8 @@ function main() {
                 process.exit(code || 0);
             });
         } else {
-            // For help command
-            commandHandler();
+            console.error(`❌ Invalid command handler for: ${command}`);
+            process.exit(1);
         }
     } catch (error) {
         console.error(`❌ Error running command:`, error.message);

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

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/**
+ * Wrapper script that checks for bun first, then tsx, then falls back to node with tsx
+ * This ensures compatibility across different environments
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const scriptPath = path.join(__dirname, 'cli-extract-types-auto.ts');
+const args = process.argv.slice(2);
+
+// Check if a command is available
+function checkCommand(command) {
+  return new Promise((resolve) => {
+    const check = spawn(command, ['--version'], {
+      stdio: 'ignore',
+      shell: true
+    });
+    
+    check.on('error', () => resolve(false));
+    check.on('close', (code) => resolve(code === 0));
+  });
+}
+
+// Check if tsx is available in node_modules
+function findTsxInNodeModules() {
+  let currentDir = __dirname;
+  while (currentDir !== path.dirname(currentDir)) {
+    const tsxPath = path.join(currentDir, 'node_modules', '.bin', 'tsx');
+    if (fs.existsSync(tsxPath)) {
+      return tsxPath;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return null;
+}
+
+async function run() {
+  // Try bun first (faster, native TypeScript support)
+  if (await checkCommand('bun')) {
+    const proc = spawn('bun', [scriptPath, ...args], {
+      stdio: 'inherit',
+      shell: true
+    });
+    proc.on('error', (err) => {
+      console.error('Error running with bun:', err.message);
+      process.exit(1);
+    });
+    proc.on('exit', (code) => {
+      process.exit(code || 0);
+    });
+    return;
+  }
+
+  // Try tsx from node_modules first (if installed as dependency)
+  const tsxPath = findTsxInNodeModules();
+  if (tsxPath) {
+    const proc = spawn(tsxPath, [scriptPath, ...args], {
+      stdio: 'inherit',
+      shell: true
+    });
+    proc.on('error', (err) => {
+      console.error('Error running with tsx:', err.message);
+      process.exit(1);
+    });
+    proc.on('exit', (code) => {
+      process.exit(code || 0);
+    });
+    return;
+  }
+
+  // Try global tsx
+  if (await checkCommand('tsx')) {
+    const proc = spawn('tsx', [scriptPath, ...args], {
+      stdio: 'inherit',
+      shell: true
+    });
+    proc.on('error', (err) => {
+      console.error('Error running with tsx:', err.message);
+      process.exit(1);
+    });
+    proc.on('exit', (code) => {
+      process.exit(code || 0);
+    });
+    return;
+  }
+
+  // Try npx tsx as last resort (will download tsx if needed)
+  const proc = spawn('npx', ['--yes', 'tsx', scriptPath, ...args], {
+    stdio: 'inherit',
+    shell: true
+  });
+  proc.on('error', (err) => {
+    console.error('Error running with npx tsx:', err.message);
+    console.error('\nPlease install one of the following:');
+    console.error('  - bun: https://bun.sh');
+    console.error('  - tsx: npm install -g tsx (or it will be installed via npx)');
+    process.exit(1);
+  });
+  proc.on('exit', (code) => {
+    process.exit(code || 0);
+  });
+}
+
+run();
+

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 /**
  * Automatically discover and extract types for tools used in ArctenAgent/useAgent
  * Scans the project, finds all tool usages, and generates metadata only for used tools
@@ -83,6 +83,7 @@ async function findToolUsageFiles(projectRoot: string): Promise<string[]> {
     ignore: ['**/node_modules/**', '**/dist/**', '**/.next/**', '**/build/**'],
   });
 
+  console.log(`📂 Found ${files.length} TypeScript files to scan`);
   return files;
 }
 
@@ -92,8 +93,7 @@ async function findToolUsageFiles(projectRoot: string): Promise<string[]> {
 function extractToolNamesFromExpression(
   expr: ts.Expression,
   sourceFile: ts.SourceFile,
-  variableMap: Map<string, ts.Expression>,
-  program?: ts.Program
+  variableMap: Map<string, ts.Expression>
 ): { names: Set<string>; order: string[] } {
   const toolNames = new Set<string>();
   const toolOrder: string[] = []; // Preserve order
@@ -102,12 +102,6 @@ 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)) {
@@ -135,15 +129,9 @@ function extractToolNamesFromExpression(
           // Property access: tools.getOrders -> extract "getOrders"
           const propName = element.name.text;
           if (propName) {
-            // Try to resolve the module to find the actual function name
-            const resolvedName = resolvePropertyAccess(element, sourceFile, program);
-            const finalName = resolvedName || propName;
-            // 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
-              }
+            if (!toolNames.has(propName)) {
+              toolNames.add(propName);
+              toolOrder.push(propName); // Preserve order
             }
           }
         } else if (ts.isElementAccessExpression(element)) {
@@ -152,12 +140,9 @@ function extractToolNamesFromExpression(
           if (ts.isStringLiteral(indexExpr) || ts.isNumericLiteral(indexExpr)) {
             const name = indexExpr.text;
             if (name && name !== 'undefined' && name !== 'null') {
-              // Try to resolve the module
-              const resolvedName = resolveElementAccess(element, sourceFile, program);
-              const finalName = resolvedName || name;
-              if (!toolNames.has(finalName)) {
-                toolNames.add(finalName);
-                toolOrder.push(finalName); // Preserve order
+              if (!toolNames.has(name)) {
+                toolNames.add(name);
+                toolOrder.push(name); // Preserve order
               }
             }
           } else {
@@ -192,18 +177,12 @@ function extractToolNamesFromExpression(
       return;
     }
 
-    // Property access: wrappedTools.getRAGInfo or tools.getLocation
+    // Property access: wrappedTools.getRAGInfo
     if (ts.isPropertyAccessExpression(node)) {
       const propName = node.name.text;
-      // Try to resolve the module to find the actual function name
-      const resolvedName = resolvePropertyAccess(node, sourceFile, program);
-      const finalName = resolvedName || propName;
-      // 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);
-        }
+      if (!toolNames.has(propName)) {
+        toolNames.add(propName);
+        toolOrder.push(propName);
       }
       return;
     }
@@ -213,20 +192,26 @@ function extractToolNamesFromExpression(
       const callExpr = node.expression;
       if (ts.isIdentifier(callExpr)) {
         const funcName = callExpr.text;
-        if (funcName === 'useMemo') {
-          const memoizedExpr = extractToolsFromUseMemo(node, sourceFile, variableMap);
-          if (memoizedExpr) {
-            extractFromExpr(memoizedExpr);
+        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
           }
-        }
-      }
-      // Also handle other function calls that might return arrays
-      // For example: someFunction() that returns an array of tools
-      if (node.arguments.length === 0) {
-        // Check if this call might be a variable reference
-        const varExpr = variableMap.get(callExpr.getText(sourceFile));
-        if (varExpr) {
-          extractFromExpr(varExpr);
         }
       }
       return;
@@ -243,60 +228,8 @@ function extractToolNamesFromExpression(
   return { names: toolNames, order: toolOrder };
 }
 
-/**
- * Resolve property access like tools.getLocation to find the actual function name
- * Returns the resolved name if found, or null if couldn't resolve
- */
-function resolvePropertyAccess(
-  expr: ts.PropertyAccessExpression,
-  sourceFile: ts.SourceFile,
-  program?: ts.Program
-): string | null {
-  if (!program) return null;
-  
-  const checker = program.getTypeChecker();
-  const symbol = checker.getSymbolAtLocation(expr);
-  
-  if (symbol) {
-    // Get the name of the property (e.g., "getLocation")
-    return symbol.getName();
-  }
-  
-  // Fallback: try to resolve the object (e.g., "tools")
-  const objectExpr = expr.expression;
-  if (ts.isIdentifier(objectExpr)) {
-    const objectName = objectExpr.text;
-    // Check if this is an imported module (e.g., import * as tools from "./tools")
-    // We'll handle this in the import resolution
-    return null;
-  }
-  
-  return null;
-}
-
-/**
- * Resolve element access like tools['getLocation'] to find the actual function name
- */
-function resolveElementAccess(
-  expr: ts.ElementAccessExpression,
-  sourceFile: ts.SourceFile,
-  program?: ts.Program
-): string | null {
-  if (!program) return null;
-  
-  const checker = program.getTypeChecker();
-  const symbol = checker.getSymbolAtLocation(expr);
-  
-  if (symbol) {
-    return symbol.getName();
-  }
-  
-  return null;
-}
-
 /**
  * Build a map of variable declarations in the file
- * Handles: const x = [...], const x = useMemo(...), etc.
  */
 function buildVariableMap(sourceFile: ts.SourceFile): Map<string, ts.Expression> {
   const variableMap = new Map<string, ts.Expression>();
@@ -325,58 +258,6 @@ function buildVariableMap(sourceFile: ts.SourceFile): Map<string, ts.Expression>
   return variableMap;
 }
 
-/**
- * Extract tools from useMemo callback, handling both arrow functions and regular functions
- * Also handles type assertions like `as any`
- */
-function extractToolsFromUseMemo(
-  useMemoCall: ts.CallExpression,
-  sourceFile: ts.SourceFile,
-  variableMap: Map<string, ts.Expression>
-): ts.Expression | null {
-  if (useMemoCall.arguments.length === 0) return null;
-  
-  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) {
-      return extractFromBody(firstArg.body);
-    }
-  }
-  // Regular function: function() { return [...] }
-  else if (ts.isFunctionExpression(firstArg) && firstArg.body) {
-    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
  */
@@ -407,7 +288,7 @@ function extractToolNamesFromFile(
               if (attr.initializer && ts.isJsxExpression(attr.initializer)) {
                 const expr = attr.initializer.expression;
                 if (expr) {
-                  const extracted = extractToolNamesFromExpression(expr, sourceFile, variableMap, program);
+                  const extracted = extractToolNamesFromExpression(expr, sourceFile, variableMap);
                   extracted.names.forEach(name => toolNames.add(name));
                 }
               }
@@ -425,7 +306,7 @@ function extractToolNamesFromFile(
                 if (attr.initializer && ts.isJsxExpression(attr.initializer)) {
                   const expr = attr.initializer.expression;
                   if (expr) {
-                    const extracted = extractToolNamesFromExpression(expr, sourceFile, variableMap, program);
+                    const extracted = extractToolNamesFromExpression(expr, sourceFile, variableMap);
                     allToolOrder.push(...extracted.order);
                   }
                 }
@@ -459,8 +340,7 @@ function extractToolNamesFromFile(
                   const extracted = extractToolNamesFromExpression(
                     prop.initializer,
                     sourceFile,
-                    variableMap,
-                    program
+                    variableMap
                   );
                   extracted.names.forEach(name => toolNames.add(name));
                 }
@@ -482,8 +362,7 @@ function extractToolNamesFromFile(
                     const extracted = extractToolNamesFromExpression(
                       prop.initializer,
                       sourceFile,
-                      variableMap,
-                      program
+                      variableMap
                     );
                     allToolOrder.push(...extracted.order);
                   }
@@ -559,31 +438,30 @@ function findFunctionDefinition(
     return { sourceFile, node: foundNode };
   }
 
-  // If not found, check imports
-  const imports: { name: string; from: string; isNamespace?: boolean }[] = [];
+  // If not found, check imports (both named and namespace imports)
+  const imports: { name: string; from: string; isNamespace: boolean }[] = [];
 
   function visitForImports(node: ts.Node) {
     if (ts.isImportDeclaration(node)) {
       const importClause = node.importClause;
-      const modulePath = (node.moduleSpecifier as ts.StringLiteral).text;
-      
       if (importClause) {
         const namedBindings = importClause.namedBindings;
-        
-        // Handle namespace imports: import * as tools from "./tools"
-        if (namedBindings && ts.isNamespaceImport(namedBindings)) {
-          const namespaceName = namedBindings.name.getText(sourceFile);
-          // Check if functionName matches the namespace (e.g., "tools" in tools.getLocation)
-          // We'll handle property access separately
-          imports.push({ name: namespaceName, from: modulePath, isNamespace: true });
-        }
-        // Handle named imports: import { getLocation } from "./tools"
-        else if (namedBindings && ts.isNamedImports(namedBindings)) {
-          for (const element of namedBindings.elements) {
-            const importedName = element.name.getText(sourceFile);
-            if (importedName === functionName) {
-              imports.push({ name: importedName, from: modulePath });
+        if (namedBindings) {
+          if (ts.isNamedImports(namedBindings)) {
+            // Named imports: import { getLocation, resetPassword } from './tools'
+            for (const element of namedBindings.elements) {
+              const importedName = element.name.getText(sourceFile);
+              if (importedName === functionName) {
+                const modulePath = (node.moduleSpecifier as ts.StringLiteral).text;
+                imports.push({ name: importedName, from: modulePath, isNamespace: false });
+              }
             }
+          } else if (ts.isNamespaceImport(namedBindings)) {
+            // Namespace import: import * as tools from './tools'
+            // When we have tools.getLocation, we need to search in the imported module
+            const namespaceName = namedBindings.name.getText(sourceFile);
+            const modulePath = (node.moduleSpecifier as ts.StringLiteral).text;
+            imports.push({ name: namespaceName, from: modulePath, isNamespace: true });
           }
         }
       }
@@ -599,16 +477,16 @@ function findFunctionDefinition(
     if (resolvedPath) {
       const importedSourceFile = program.getSourceFile(resolvedPath);
       if (importedSourceFile) {
-        // For namespace imports, search for the function name in the imported module
         if (imp.isNamespace) {
-          // The functionName should be found directly in the imported module
+          // For namespace imports, search for the function name directly in the module
+          // (e.g., tools.getLocation -> search for "getLocation" in the tools module)
           const result = findFunctionDefinition(functionName, importedSourceFile, program);
           if (result) {
             return result;
           }
         } else {
-          // For named imports, the name matches
-          const result = findFunctionDefinition(functionName, importedSourceFile, program);
+          // For named imports, the imported name matches the function name
+          const result = findFunctionDefinition(imp.name, importedSourceFile, program);
           if (result) {
             return result;
           }
@@ -1497,11 +1375,10 @@ async function extractFunctionMetadata(
  * Main function
  */
 async function autoDiscoverAndExtract(projectRoot: string, outputPath: string) {
-  console.log(`\n🔍 Discovering tools in your project...\n`);
+  console.log(`\n🔍 Auto-discovering tools in: ${projectRoot}\n`);
 
   // Find all TypeScript files
   const files = await findToolUsageFiles(projectRoot);
-  console.log(`📂 Scanning ${files.length} TypeScript file${files.length !== 1 ? 's' : ''}...`);
 
   // Read tsconfig
   const configPath = ts.findConfigFile(projectRoot, ts.sys.fileExists, 'tsconfig.json');
@@ -1536,34 +1413,19 @@ async function autoDiscoverAndExtract(projectRoot: string, outputPath: string) {
     }
   }
 
-  if (allToolUsages.length === 0) {
-    console.log(`\n⚠️  No tool usages found in ArctenAgent or useAgent components`);
-    console.log(`\n💡 Make sure you're using tools like this:`);
-    console.log(`   <ArctenAgent safeTools={[getLocation, resetPassword]} />`);
-    console.log(`   or`);
-    console.log(`   useAgent({ safeTools: [getLocation, resetPassword] })\n`);
-    return;
-  }
-
-  console.log(`\n✨ Found ${allToolUsages.length} usage site${allToolUsages.length !== 1 ? 's' : ''} with ${allToolNames.size} unique tool${allToolNames.size !== 1 ? 's' : ''}:`);
-  allToolUsages.forEach((usage, idx) => {
-    const relativePath = path.relative(projectRoot, usage.file);
-    const tools = Array.from(usage.toolNames);
-    console.log(`\n   ${idx + 1}. ${usage.component} in ${relativePath}`);
-    console.log(`      Tools: ${tools.map(t => `\x1b[36m${t}\x1b[0m`).join(', ')}`);
+  console.log(`✓ Found ${allToolUsages.length} usage site(s) with ${allToolNames.size} unique tool(s)`);
+  allToolUsages.forEach(usage => {
+    console.log(`  - ${usage.component} in ${path.relative(projectRoot, usage.file)}`);
+    console.log(`    Tools: ${Array.from(usage.toolNames).join(', ')}`);
   });
 
   // Extract metadata for discovered tools
-  console.log(`\n📝 Extracting type metadata...\n`);
+  console.log(`\n📝 Extracting types for discovered tools...\n`);
 
   const functionsMap: Record<string, FunctionMetadata> = {};
   const discoveredFrom: string[] = [];
 
-  const toolNamesArray = Array.from(allToolNames);
-  let successCount = 0;
-  let warningCount = 0;
-
-  for (const toolName of toolNamesArray) {
+  for (const toolName of allToolNames) {
     let found = false;
 
     // Search in all files for the definition
@@ -1576,10 +1438,8 @@ async function autoDiscoverAndExtract(projectRoot: string, outputPath: string) {
           if (metadata) {
             functionsMap[toolName] = metadata;
             discoveredFrom.push(path.relative(projectRoot, result.sourceFile.fileName));
-            const relativePath = path.relative(projectRoot, result.sourceFile.fileName);
-            console.log(`   ✓ \x1b[32m${toolName}\x1b[0m \x1b[90m(${relativePath})\x1b[0m`);
+            console.log(`  ✓ ${toolName} (from ${path.relative(projectRoot, result.sourceFile.fileName)})`);
             found = true;
-            successCount++;
             break;
           }
         }
@@ -1587,8 +1447,7 @@ async function autoDiscoverAndExtract(projectRoot: string, outputPath: string) {
     }
 
     if (!found) {
-      console.log(`   ⚠ \x1b[33m${toolName}\x1b[0m \x1b[90m(definition not found)\x1b[0m`);
-      warningCount++;
+      console.log(`  ⚠ ${toolName} (definition not found)`);
     }
   }
 
@@ -1639,24 +1498,11 @@ export const toolMetadata = ${JSON.stringify(output, null, 2)} as const;
 `;
 
   fs.writeFileSync(outputPath, tsContent);
-  
-  const relativeOutput = path.relative(projectRoot, outputPath);
-  
-  console.log(`\n${'='.repeat(60)}`);
-  if (successCount > 0) {
-    console.log(`✅ Successfully extracted ${successCount} tool${successCount !== 1 ? 's' : ''}`);
-  }
-  if (warningCount > 0) {
-    console.log(`⚠️  ${warningCount} tool${warningCount !== 1 ? 's' : ''} not found (check function names)`);
-  }
-  console.log(`📁 Output: \x1b[36m${relativeOutput}\x1b[0m`);
-  console.log(`${'='.repeat(60)}\n`);
-  
-  if (successCount > 0) {
-    console.log(`💡 Usage in your component:`);
-    console.log(`   import { toolMetadata } from './.arcten/tool-metadata';`);
-    console.log(`   useAgent({ tools: [...], toolMetadata: toolMetadata.functions })\n`);
-  }
+  console.log(`\n✅ Generated metadata for ${Object.keys(functionsMap).length} tool(s)`);
+  console.log(`📁 Output: ${outputPath}`);
+  console.log(`\n💡 Usage in your component:`);
+  console.log(`   import { toolMetadata } from './.arcten/tool-metadata';`);
+  console.log(`   useAgent({ tools: [...], toolMetadata: toolMetadata.functions })\n`);
 }
 
 // CLI

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

@@ -1,93 +0,0 @@
-#!/usr/bin/env node
-/**
- * Wrapper script to run the TypeScript CLI
- * Works with Node.js - no bun required!
- */
-
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, 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 a command is available
-function checkCommand(cmd) {
-  return new Promise((resolve) => {
-    const check = spawn(cmd, ['--version'], { stdio: 'ignore', shell: true });
-    check.on('close', (code) => {
-      resolve(code === 0);
-    });
-    check.on('error', () => {
-      resolve(false);
-    });
-  });
-}
-
-async function main() {
-  if (!existsSync(tsScript)) {
-    console.error(`❌ Error: Script not found at ${tsScript}`);
-    process.exit(1);
-  }
-
-  const args = process.argv.slice(2);
-
-  // Check for bun first (faster and preferred if available)
-  const hasBun = await checkCommand('bun');
-
-  if (hasBun) {
-    // Use bun directly - it's faster and can run TypeScript natively
-    const bunProcess = spawn('bun', [tsScript, ...args], {
-      stdio: 'inherit',
-      shell: true
-    });
-
-    bunProcess.on('close', (code) => {
-      process.exit(code || 0);
-    });
-
-    bunProcess.on('error', (err) => {
-      // If bun fails, try tsx as fallback
-      tryTsxFallback(args);
-    });
-  } else {
-    // Fallback to tsx via npx if bun isn't available
-    tryTsxFallback(args);
-  }
-}
-
-async function tryTsxFallback(args) {
-  const hasNpx = await checkCommand('npx');
-
-  if (hasNpx) {
-    // Use tsx via npx - it's lightweight and works great with Node.js
-    const tsxProcess = spawn('npx', ['-y', 'tsx', tsScript, ...args], {
-      stdio: 'inherit',
-      shell: true
-    });
-
-    tsxProcess.on('close', (code) => {
-      process.exit(code || 0);
-    });
-
-    tsxProcess.on('error', (err) => {
-      console.error('❌ Error: Could not run script');
-      console.error('Please ensure you have Node.js (with npx) or bun installed');
-      process.exit(1);
-    });
-  } else {
-    console.error('❌ Error: Could not find a TypeScript runner');
-    console.error('');
-    console.error('Please install one of the following:');
-    console.error('  - bun: curl -fsSL https://bun.sh/install | bash (recommended)');
-    console.error('  - Node.js (comes with npx)');
-    process.exit(1);
-  }
-}
-
-main();
-

package/scripts/postinstall-check-version.cjs

@@ -1,157 +0,0 @@
-#!/usr/bin/env node
-/**
- * Postinstall script to check and optionally update @arcteninc/core version
- * This helps users stay on the latest version without manually updating package.json
- */
-
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-function findPackageJson(startPath = process.cwd()) {
-  let currentPath = startPath;
-  
-  // Start from current directory and walk up to find package.json
-  // Skip node_modules directories
-  while (currentPath !== path.dirname(currentPath)) {
-    // Skip if we're in a node_modules directory
-    if (currentPath.includes('node_modules')) {
-      currentPath = path.dirname(currentPath);
-      continue;
-    }
-    
-    const packageJsonPath = path.join(currentPath, 'package.json');
-    if (fs.existsSync(packageJsonPath)) {
-      // Make sure this isn't @arcteninc/core's own package.json
-      try {
-        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-        if (pkg.name === '@arcteninc/core') {
-          // This is the core package itself, go up one level
-          currentPath = path.dirname(currentPath);
-          continue;
-        }
-      } catch (e) {
-        // Invalid JSON, skip
-        currentPath = path.dirname(currentPath);
-        continue;
-      }
-      
-      return packageJsonPath;
-    }
-    currentPath = path.dirname(currentPath);
-  }
-  
-  return null;
-}
-
-function getLatestVersion() {
-  try {
-    const output = execSync('npm view @arcteninc/core version', { encoding: 'utf-8', stdio: 'pipe' });
-    return output.trim();
-  } catch (error) {
-    console.warn('⚠️  Could not check latest version:', error.message);
-    return null;
-  }
-}
-
-function getInstalledVersion() {
-  try {
-    const packageJsonPath = findPackageJson();
-    if (!packageJsonPath) {
-      return null;
-    }
-    
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-    const version = deps['@arcteninc/core'];
-    
-    return version ? { version, packageJsonPath, packageJson } : null;
-  } catch (error) {
-    return null;
-  }
-}
-
-// Removed auto-update function - users should update manually
-
-function main() {
-  // Find the user's project root (not node_modules/@arcteninc/core)
-  // Walk up from current directory to find package.json that uses @arcteninc/core
-  let projectRoot = process.cwd();
-  
-  // If we're in node_modules/@arcteninc/core, go up to project root
-  if (projectRoot.includes('node_modules')) {
-    // Find the project root by looking for package.json that's not @arcteninc/core
-    const parts = projectRoot.split(path.sep);
-    const nodeModulesIndex = parts.indexOf('node_modules');
-    if (nodeModulesIndex !== -1) {
-      projectRoot = parts.slice(0, nodeModulesIndex).join(path.sep);
-    }
-  }
-  
-  // Change to project root to find package.json
-  const originalCwd = process.cwd();
-  try {
-    process.chdir(projectRoot);
-  } catch (e) {
-    // Can't change directory, use original
-  }
-  
-  // Only run if we're in a project that uses @arcteninc/core
-  const installed = getInstalledVersion();
-  if (!installed) {
-    process.chdir(originalCwd);
-    return; // Not installed, nothing to do
-  }
-  
-  const latestVersion = getLatestVersion();
-  if (!latestVersion) {
-    try {
-      process.chdir(originalCwd);
-    } catch (e) {
-      // Ignore
-    }
-    return; // Couldn't check, skip
-  }
-  
-  // Extract current version number (remove ^, ~, etc.)
-  const currentVersionMatch = installed.version.match(/(\d+\.\d+\.\d+)/);
-  if (!currentVersionMatch) {
-    try {
-      process.chdir(originalCwd);
-    } catch (e) {
-      // Ignore
-    }
-    return; // Invalid version format
-  }
-  
-  const currentVersion = currentVersionMatch[1];
-  
-  if (currentVersion !== latestVersion) {
-    console.log(`\n📦 @arcteninc/core update available:`);
-    console.log(`   Current: ${currentVersion}`);
-    console.log(`   Latest:  ${latestVersion}`);
-    
-    if (installed.version.startsWith('^') || installed.version.startsWith('~')) {
-      console.log(`   Run 'npm update @arcteninc/core' to update within your version range`);
-    } else {
-      console.log(`   Consider updating to '^${latestVersion}' in package.json`);
-      console.log(`   Then run 'npm install' to get the latest version`);
-    }
-    console.log(`   Or use: \x1b[36mnpx arcten update\x1b[0m`);
-  }
-  
-  // Restore original directory
-  try {
-    process.chdir(originalCwd);
-  } catch (e) {
-    // Ignore
-  }
-}
-
-// Only run if called directly (not when required)
-if (require.main === module) {
-  main();
-}
-
-module.exports = { main, getLatestVersion, getInstalledVersion, findPackageJson };
-

package/scripts/update-core.cjs

@@ -1,125 +0,0 @@
-#!/usr/bin/env node
-/**
- * Manual update command for @arcteninc/core
- * Usage: arcten update
- * 
- * This allows users to explicitly update their package.json
- */
-
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-const { findPackageJson } = require('./postinstall-check-version.cjs');
-
-function findPackageJsonLocal(startPath = process.cwd()) {
-  let currentPath = startPath;
-  
-  while (currentPath !== path.dirname(currentPath)) {
-    if (currentPath.includes('node_modules')) {
-      currentPath = path.dirname(currentPath);
-      continue;
-    }
-    
-    const packageJsonPath = path.join(currentPath, 'package.json');
-    if (fs.existsSync(packageJsonPath)) {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-        if (pkg.name === '@arcteninc/core') {
-          currentPath = path.dirname(currentPath);
-          continue;
-        }
-      } catch (e) {
-        currentPath = path.dirname(currentPath);
-        continue;
-      }
-      
-      return packageJsonPath;
-    }
-    currentPath = path.dirname(currentPath);
-  }
-  
-  return null;
-}
-
-function getLatestVersion() {
-  try {
-    const output = execSync('npm view @arcteninc/core version', { encoding: 'utf-8', stdio: 'pipe' });
-    return output.trim();
-  } catch (error) {
-    console.error('❌ Could not check latest version:', error.message);
-    return null;
-  }
-}
-
-function updateVersion(packageJsonPath, packageJson, latestVersion) {
-  let updated = false;
-  
-  if (packageJson.dependencies && packageJson.dependencies['@arcteninc/core']) {
-    packageJson.dependencies['@arcteninc/core'] = `^${latestVersion}`;
-    updated = true;
-  }
-  if (packageJson.devDependencies && packageJson.devDependencies['@arcteninc/core']) {
-    packageJson.devDependencies['@arcteninc/core'] = `^${latestVersion}`;
-    updated = true;
-  }
-  
-  if (updated) {
-    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
-    console.log(`✅ Updated to \x1b[32m^${latestVersion}\x1b[0m in package.json\n`);
-    return true;
-  }
-  
-  return false;
-}
-
-function main() {
-  const packageJsonPath = findPackageJson();
-  if (!packageJsonPath) {
-    console.error('❌ Could not find package.json');
-    process.exit(1);
-  }
-  
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-  const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-  const currentVersion = deps['@arcteninc/core'];
-  
-  if (!currentVersion) {
-    console.error('❌ @arcteninc/core not found in dependencies');
-    process.exit(1);
-  }
-  
-  const latestVersion = getLatestVersion();
-  if (!latestVersion) {
-    process.exit(1);
-  }
-  
-  const currentVersionMatch = currentVersion.match(/(\d+\.\d+\.\d+)/);
-  if (!currentVersionMatch) {
-    console.error('❌ Invalid version format:', currentVersion);
-    process.exit(1);
-  }
-  
-  const current = currentVersionMatch[1];
-  
-  if (current === latestVersion) {
-    console.log(`\n✅ Already on latest version: \x1b[32m${latestVersion}\x1b[0m\n`);
-    return;
-  }
-  
-  console.log(`\n📦 Updating @arcteninc/core\n`);
-  console.log(`   Current: \x1b[33m${current}\x1b[0m`);
-  console.log(`   Latest:  \x1b[32m${latestVersion}\x1b[0m\n`);
-  
-  if (updateVersion(packageJsonPath, packageJson, latestVersion)) {
-    console.log(`💡 Next steps:`);
-    console.log(`   1. Review the changes in package.json`);
-    console.log(`   2. Run \x1b[36mnpm install\x1b[0m to install the update\n`);
-  }
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = { main };
-