@arcteninc/core 0.0.58 → 0.0.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcteninc/core",
-  "version": "0.0.58",
+  "version": "0.0.60",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -20,17 +20,21 @@
   },
   "sideEffects": false,
   "bin": {
-    "arcten-extract-types": "./scripts/cli-extract-types-auto.js"
+    "arcten": "./scripts/arcten-cli.js"
   },
   "files": [
     "dist",
     "scripts/cli-extract-types-auto.ts",
-    "scripts/cli-extract-types-auto.js"
+    "scripts/cli-extract-types-auto.js",
+    "scripts/arcten-cli.js",
+    "scripts/postinstall-check-version.js",
+    "scripts/update-core.js"
   ],
   "scripts": {
     "dev": "vite build --watch",
     "build": "vite build",
-    "prepublishOnly": "bun run build"
+    "prepublishOnly": "bun run build",
+    "postinstall": "node scripts/postinstall-check-version.js"
   },
   "peerDependencies": {
     "ai": "^6.0.0-beta.94",

package/scripts/arcten-cli.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+/**
+ * Arcten CLI - Unified command interface
+ * Usage: arcten <command> [options]
+ * 
+ * Commands:
+ *   extract-types, tools  Extract tool metadata from your project
+ *   update                Update @arcteninc/core to latest version
+ *   help                  Show help message
+ */
+
+const { spawn } = require('child_process');
+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'),
+    'help': showHelp,
+    '--help': showHelp,
+    '-h': showHelp,
+};
+
+function showHelp() {
+    console.log(`
+📦 Arcten CLI
+
+Usage: arcten <command> [options]
+
+Commands:
+  extract-types, tools    Extract tool metadata from your project
+                          Alias: arcten tools
+  
+  update                  Update @arcteninc/core to latest version
+                          Updates package.json and shows next steps
+  
+  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
+
+For more information, visit https://github.com/arcteninc/core
+`);
+    process.exit(0);
+}
+
+function main() {
+    const args = process.argv.slice(2);
+
+    if (args.length === 0) {
+        showHelp();
+        return;
+    }
+
+    const command = args[0];
+    const commandArgs = args.slice(1);
+
+    if (!commands[command]) {
+        console.error(`❌ Unknown command: ${command}`);
+        console.error(`\nRun 'arcten help' for available commands`);
+        process.exit(1);
+    }
+
+    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
+            let scriptPath;
+            let runner = 'node';
+
+            if (command === 'update') {
+                scriptPath = path.join(__dirname, 'update-core.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);
+                }
+            }
+
+            if (!fs.existsSync(scriptPath)) {
+                console.error(`❌ Script not found: ${scriptPath}`);
+                process.exit(1);
+            }
+
+            // Spawn the script with remaining args
+            const child = spawn(runner, [scriptPath, ...commandArgs], {
+                stdio: 'inherit',
+                cwd: process.cwd(),
+                shell: true // Use shell to find bun/node in PATH
+            });
+
+            child.on('error', (error) => {
+                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`);
+                }
+                process.exit(1);
+            });
+
+            child.on('exit', (code) => {
+                process.exit(code || 0);
+            });
+        } else {
+            // For help command
+            commandHandler();
+        }
+    } catch (error) {
+        console.error(`❌ Error running command:`, error.message);
+        process.exit(1);
+    }
+}
+
+if (require.main === module) {
+    main();
+}
+
+module.exports = { main };
+

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

@@ -1,93 +1,93 @@
-#!/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();
-
+#!/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/cli-extract-types-auto.ts

@@ -83,7 +83,6 @@ async function findToolUsageFiles(projectRoot: string): Promise<string[]> {
     ignore: ['**/node_modules/**', '**/dist/**', '**/.next/**', '**/build/**'],
   });
 
-  console.log(`📂 Found ${files.length} TypeScript files to scan`);
   return files;
 }
 
@@ -192,25 +191,10 @@ function extractToolNamesFromExpression(
       const callExpr = node.expression;
       if (ts.isIdentifier(callExpr)) {
         const funcName = callExpr.text;
-        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
+        if (funcName === 'useMemo') {
+          const memoizedExpr = extractToolsFromUseMemo(node, sourceFile, variableMap);
+          if (memoizedExpr) {
+            extractFromExpr(memoizedExpr);
           }
         }
       }
@@ -230,6 +214,7 @@ function extractToolNamesFromExpression(
 
 /**
  * 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>();
@@ -258,6 +243,46 @@ function buildVariableMap(sourceFile: ts.SourceFile): Map<string, ts.Expression>
   return variableMap;
 }
 
+/**
+ * Extract tools from useMemo callback, handling both arrow functions and regular functions
+ */
+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];
+  
+  // 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;
+      }
+    }
+  }
+  // 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 null;
+}
+
 /**
  * Extract tool names from ArctenAgent or useAgent usage
  */
@@ -1356,10 +1381,11 @@ async function extractFunctionMetadata(
  * Main function
  */
 async function autoDiscoverAndExtract(projectRoot: string, outputPath: string) {
-  console.log(`\n🔍 Auto-discovering tools in: ${projectRoot}\n`);
+  console.log(`\n🔍 Discovering tools in your project...\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');
@@ -1394,19 +1420,34 @@ async function autoDiscoverAndExtract(projectRoot: string, outputPath: string) {
     }
   }
 
-  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(', ')}`);
+  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(', ')}`);
   });
 
   // Extract metadata for discovered tools
-  console.log(`\n📝 Extracting types for discovered tools...\n`);
+  console.log(`\n📝 Extracting type metadata...\n`);
 
   const functionsMap: Record<string, FunctionMetadata> = {};
   const discoveredFrom: string[] = [];
 
-  for (const toolName of allToolNames) {
+  const toolNamesArray = Array.from(allToolNames);
+  let successCount = 0;
+  let warningCount = 0;
+
+  for (const toolName of toolNamesArray) {
     let found = false;
 
     // Search in all files for the definition
@@ -1419,8 +1460,10 @@ async function autoDiscoverAndExtract(projectRoot: string, outputPath: string) {
           if (metadata) {
             functionsMap[toolName] = metadata;
             discoveredFrom.push(path.relative(projectRoot, result.sourceFile.fileName));
-            console.log(`  ✓ ${toolName} (from ${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`);
             found = true;
+            successCount++;
             break;
           }
         }
@@ -1428,7 +1471,8 @@ async function autoDiscoverAndExtract(projectRoot: string, outputPath: string) {
     }
 
     if (!found) {
-      console.log(`  ⚠ ${toolName} (definition not found)`);
+      console.log(`   ⚠ \x1b[33m${toolName}\x1b[0m \x1b[90m(definition not found)\x1b[0m`);
+      warningCount++;
     }
   }
 
@@ -1479,11 +1523,24 @@ export const toolMetadata = ${JSON.stringify(output, null, 2)} as const;
 `;
 
   fs.writeFileSync(outputPath, tsContent);
-  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`);
+  
+  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`);
+  }
 }
 
 // CLI