@arcteninc/core 0.0.24 → 0.0.26

package/package.json

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

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

@@ -0,0 +1,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);
+  
+  // Try tsx first (lightweight TypeScript runner for Node.js)
+  // Use npx to run it without requiring installation
+  const hasTsx = await checkCommand('npx');
+  
+  if (hasTsx) {
+    // 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) => {
+      // If tsx fails, try bun as fallback
+      tryBunFallback(args);
+    });
+  } else {
+    // Fallback to bun if npx isn't available
+    tryBunFallback(args);
+  }
+}
+
+async function tryBunFallback(args) {
+  const hasBun = await checkCommand('bun');
+  
+  if (hasBun) {
+    const bunProcess = spawn('bun', [tsScript, ...args], {
+      stdio: 'inherit',
+      shell: true
+    });
+
+    bunProcess.on('close', (code) => {
+      process.exit(code || 0);
+    });
+
+    bunProcess.on('error', (err) => {
+      console.error('❌ Error: 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('  - Node.js (comes with npx) - recommended');
+    console.error('  - bun: curl -fsSL https://bun.sh/install | bash');
+    process.exit(1);
+  }
+}
+
+main();
+

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

@@ -78,11 +78,25 @@ function extractToolNamesFromExpression(
         if (ts.isSpreadElement(element)) {
           // Handle spread: [...someArray]
           extractFromExpr(element.expression);
+        } else if (ts.isArrowFunction(element) || ts.isFunctionExpression(element)) {
+          // Skip anonymous functions - they don't have names to extract
+          // Example: tools: [function getStatus() { ... }] - this should have a name
+          if (ts.isFunctionExpression(element) && element.name) {
+            toolNames.add(element.name.getText(sourceFile));
+          }
+          // For arrow functions without names, skip them
         } else {
           const name = element.getText(sourceFile).trim();
           // Remove any object property access (e.g., tools.getOrders -> getOrders)
           const simpleName = name.split('.').pop() || name;
-          if (simpleName && simpleName !== 'undefined' && simpleName !== 'null') {
+          // Skip if it looks like code (contains operators, semicolons, etc.)
+          if (simpleName && 
+              simpleName !== 'undefined' && 
+              simpleName !== 'null' &&
+              !simpleName.includes('?') &&
+              !simpleName.includes(';') &&
+              !simpleName.includes('=>') &&
+              simpleName.length < 100) {
             toolNames.add(simpleName);
           }
         }
@@ -329,9 +343,9 @@ function findFunctionDefinition(
 
   function visitForImports(node: ts.Node) {
     if (ts.isImportDeclaration(node)) {
-      const moduleSpecifier = node.moduleClause;
-      if (moduleSpecifier && ts.isImportClause(moduleSpecifier)) {
-        const namedBindings = moduleSpecifier.namedBindings;
+      const importClause = node.importClause;
+      if (importClause) {
+        const namedBindings = importClause.namedBindings;
         if (namedBindings && ts.isNamedImports(namedBindings)) {
           for (const element of namedBindings.elements) {
             const importedName = element.name.getText(sourceFile);