@arcteninc/core 0.0.57 → 0.0.59

package/dist/lib/useAgent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAgent.d.ts","sourceRoot":"","sources":["../../src/lib/useAgent.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EAGf,MAAM,oBAAoB,CAAC;AAoE5B,wBAAgB,QAAQ,CAAC,EACvB,UAAqC,EACrC,aAAmC,EACnC,WAAW,EAAE,aAAa,EAC1B,cAAsB,EACtB,IAAI,EACJ,KAAU,EACV,SAAc,EACd,YAAY,EACZ,YAAiB,EACjB,eAAoB,EACpB,cAAc,EAAE,qBAAqB,EACrC,UAAU,EACV,QAAQ,EACR,UAAU,GACX,GAAE,eAAoB,GAAG,cAAc,CAodvC"}
+{"version":3,"file":"useAgent.d.ts","sourceRoot":"","sources":["../../src/lib/useAgent.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EAGf,MAAM,oBAAoB,CAAC;AAoE5B,wBAAgB,QAAQ,CAAC,EACvB,UAAqC,EACrC,aAAmC,EACnC,WAAW,EAAE,aAAa,EAC1B,cAAsB,EACtB,IAAI,EACJ,KAAU,EACV,SAAc,EACd,YAAY,EACZ,YAAiB,EACjB,eAAoB,EACpB,cAAc,EAAE,qBAAqB,EACrC,UAAU,EACV,QAAQ,EACR,UAAU,GACX,GAAE,eAAoB,GAAG,cAAc,CAuZvC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcteninc/core",
-  "version": "0.0.57",
+  "version": "0.0.59",
   "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-extract-types": "./scripts/cli-extract-types-auto.js",
+    "arcten-update-core": "./scripts/update-core.js"
   },
   "files": [
     "dist",
     "scripts/cli-extract-types-auto.ts",
-    "scripts/cli-extract-types-auto.js"
+    "scripts/cli-extract-types-auto.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/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

@@ -192,25 +192,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 +215,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 +244,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
  */

package/scripts/postinstall-check-version.js

@@ -0,0 +1,157 @@
+#!/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: npx arcten-update-core`);
+  }
+  
+  // 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.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * Manual update command for @arcteninc/core
+ * Usage: npx arcten-update-core
+ * 
+ * This allows users to explicitly update their package.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function findPackageJson(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 @arcteninc/core to ^${latestVersion} in package.json`);
+    console.log(`   Run 'npm install' to install the latest version`);
+    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(`✅ Already on latest version: ${latestVersion}`);
+    return;
+  }
+  
+  console.log(`📦 Updating @arcteninc/core:`);
+  console.log(`   Current: ${current}`);
+  console.log(`   Latest:  ${latestVersion}`);
+  
+  if (updateVersion(packageJsonPath, packageJson, latestVersion)) {
+    console.log(`\n💡 Next steps:`);
+    console.log(`   1. Review the changes in package.json`);
+    console.log(`   2. Run 'npm install' to install the update`);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main };
+