@arcteninc/core 0.0.61 → 0.0.63

package/package.json

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

package/scripts/arcten-cli.cjs

@@ -1,132 +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.cjs');
-            } 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 };
-
+#!/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.cjs');
+            } 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.ts

@@ -92,7 +92,8 @@ async function findToolUsageFiles(projectRoot: string): Promise<string[]> {
 function extractToolNamesFromExpression(
   expr: ts.Expression,
   sourceFile: ts.SourceFile,
-  variableMap: Map<string, ts.Expression>
+  variableMap: Map<string, ts.Expression>,
+  program?: ts.Program
 ): { names: Set<string>; order: string[] } {
   const toolNames = new Set<string>();
   const toolOrder: string[] = []; // Preserve order
@@ -101,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)) {
@@ -128,9 +135,15 @@ function extractToolNamesFromExpression(
           // Property access: tools.getOrders -> extract "getOrders"
           const propName = element.name.text;
           if (propName) {
-            if (!toolNames.has(propName)) {
-              toolNames.add(propName);
-              toolOrder.push(propName); // Preserve order
+            // 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
+              }
             }
           }
         } else if (ts.isElementAccessExpression(element)) {
@@ -139,9 +152,12 @@ function extractToolNamesFromExpression(
           if (ts.isStringLiteral(indexExpr) || ts.isNumericLiteral(indexExpr)) {
             const name = indexExpr.text;
             if (name && name !== 'undefined' && name !== 'null') {
-              if (!toolNames.has(name)) {
-                toolNames.add(name);
-                toolOrder.push(name); // Preserve order
+              // 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
               }
             }
           } else {
@@ -176,12 +192,18 @@ function extractToolNamesFromExpression(
       return;
     }
 
-    // Property access: wrappedTools.getRAGInfo
+    // Property access: wrappedTools.getRAGInfo or tools.getLocation
     if (ts.isPropertyAccessExpression(node)) {
       const propName = node.name.text;
-      if (!toolNames.has(propName)) {
-        toolNames.add(propName);
-        toolOrder.push(propName);
+      // 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);
+        }
       }
       return;
     }
@@ -198,6 +220,15 @@ function extractToolNamesFromExpression(
           }
         }
       }
+      // 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;
     }
 
@@ -212,6 +243,57 @@ 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.
@@ -245,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,
@@ -255,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
  */
@@ -313,7 +407,7 @@ function extractToolNamesFromFile(
               if (attr.initializer && ts.isJsxExpression(attr.initializer)) {
                 const expr = attr.initializer.expression;
                 if (expr) {
-                  const extracted = extractToolNamesFromExpression(expr, sourceFile, variableMap);
+                  const extracted = extractToolNamesFromExpression(expr, sourceFile, variableMap, program);
                   extracted.names.forEach(name => toolNames.add(name));
                 }
               }
@@ -331,7 +425,7 @@ function extractToolNamesFromFile(
                 if (attr.initializer && ts.isJsxExpression(attr.initializer)) {
                   const expr = attr.initializer.expression;
                   if (expr) {
-                    const extracted = extractToolNamesFromExpression(expr, sourceFile, variableMap);
+                    const extracted = extractToolNamesFromExpression(expr, sourceFile, variableMap, program);
                     allToolOrder.push(...extracted.order);
                   }
                 }
@@ -365,7 +459,8 @@ function extractToolNamesFromFile(
                   const extracted = extractToolNamesFromExpression(
                     prop.initializer,
                     sourceFile,
-                    variableMap
+                    variableMap,
+                    program
                   );
                   extracted.names.forEach(name => toolNames.add(name));
                 }
@@ -387,7 +482,8 @@ function extractToolNamesFromFile(
                     const extracted = extractToolNamesFromExpression(
                       prop.initializer,
                       sourceFile,
-                      variableMap
+                      variableMap,
+                      program
                     );
                     allToolOrder.push(...extracted.order);
                   }
@@ -464,18 +560,28 @@ function findFunctionDefinition(
   }
 
   // If not found, check imports
-  const imports: { name: string; from: string }[] = [];
+  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;
-        if (namedBindings && ts.isNamedImports(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) {
-              const modulePath = (node.moduleSpecifier as ts.StringLiteral).text;
               imports.push({ name: importedName, from: modulePath });
             }
           }
@@ -493,9 +599,19 @@ function findFunctionDefinition(
     if (resolvedPath) {
       const importedSourceFile = program.getSourceFile(resolvedPath);
       if (importedSourceFile) {
-        const result = findFunctionDefinition(functionName, importedSourceFile, program);
-        if (result) {
-          return result;
+        // 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
+          const result = findFunctionDefinition(functionName, importedSourceFile, program);
+          if (result) {
+            return result;
+          }
+        } else {
+          // For named imports, the name matches
+          const result = findFunctionDefinition(functionName, importedSourceFile, program);
+          if (result) {
+            return result;
+          }
         }
       }
     }

package/scripts/update-core.cjs

@@ -1,125 +1,125 @@
-#!/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 };
-
+#!/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 };
+