@xortex/xcode 3.0.4 → 3.0.8

package/bin/xcode

@@ -1,164 +1,165 @@
 #!/usr/bin/env node
 /**
  * XCode CLI Entry Point
- * 
- * This is the executable that gets installed when users run:
- * - npm install -g @xortex/xcode
- * - Or use the curl installer
+ *
+ * This codebase is built for Bun (bun.sh). If Bun is not installed,
+ * this script installs it automatically, then hands off to Bun.
+ *
+ * Installed via: npm install -g @xortex/xcode
  */
 
+const { execSync, spawnSync } = require('child_process');
 const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 
-// Get the project root (where this script is located)
 const projectRoot = path.resolve(__dirname, '..');
 const mainScript = path.join(projectRoot, 'entrypoints', 'cli.tsx');
-const bunBundleHook = path.join(projectRoot, 'bun-bundle-hook.js');
 
-// Check if bun is available
-function getRuntime() {
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+function tryExec(cmd) {
+  try { execSync(cmd, { stdio: 'ignore' }); return true; } catch { return false; }
+}
+
+function bunBinPath() {
+  // Common Bun install locations
+  const candidates = [
+    path.join(os.homedir(), '.bun', 'bin', 'bun'),
+    '/usr/local/bin/bun',
+    '/usr/bin/bun',
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  // Try PATH
   try {
-    require('child_process').execSync('bun --version', { stdio: 'ignore' });
-    return 'bun';
+    return execSync('which bun', { encoding: 'utf8' }).trim();
   } catch {
-    try {
-      require('child_process').execSync('node --version', { stdio: 'ignore' });
-      return 'node';
-    } catch {
-      console.error('❌ Error: Neither Bun nor Node.js is installed.');
-      console.error('');
-      console.error('Please install one of the following:');
-      console.error('  • Bun (recommended): curl -fsSL https://bun.sh/install | bash');
-      console.error('  • Node.js: https://nodejs.org/');
-      console.error('');
-      process.exit(1);
+    return null;
+  }
+}
+
+function installBun() {
+  console.log('');
+  console.log('📦 XCode requires Bun runtime. Installing Bun now...');
+  console.log('   (This is a one-time setup)');
+  console.log('');
+
+  const platform = os.platform();
+
+  try {
+    if (platform === 'win32') {
+      execSync('powershell -c "irm bun.sh/install.ps1 | iex"', { stdio: 'inherit' });
+    } else {
+      // curl or wget
+      if (tryExec('which curl')) {
+        execSync('curl -fsSL https://bun.sh/install | bash', {
+          stdio: 'inherit',
+          shell: '/bin/bash',
+        });
+      } else if (tryExec('which wget')) {
+        execSync('wget -qO- https://bun.sh/install | bash', {
+          stdio: 'inherit',
+          shell: '/bin/bash',
+        });
+      } else {
+        throw new Error('Neither curl nor wget is available');
+      }
     }
+
+    console.log('');
+    console.log('✅ Bun installed successfully!');
+    console.log('');
+
+    // Re-source PATH
+    const bunBin = bunBinPath();
+    if (bunBin) return bunBin;
+
+    // Add ~/.bun/bin to PATH for this process
+    const bunBinDir = path.join(os.homedir(), '.bun', 'bin');
+    process.env.PATH = `${bunBinDir}${path.delimiter}${process.env.PATH}`;
+    return path.join(bunBinDir, 'bun');
+
+  } catch (err) {
+    console.error('');
+    console.error('❌ Could not auto-install Bun. Please install it manually:');
+    console.error('');
+    console.error('   curl -fsSL https://bun.sh/install | bash');
+    console.error('');
+    console.error('   Then run: xcode');
+    console.error('');
+    process.exit(1);
   }
 }
 
-// Set up environment
+// ── CLI flags ─────────────────────────────────────────────────────────────────
+
 process.env.XCODE_CLI = 'true';
 process.env.NODE_ENV = process.env.NODE_ENV || 'production';
 
-// Handle special commands
 const args = process.argv.slice(2);
-const command = args[0];
 
-if (command === '--version' || command === '-v') {
-  console.log('xcode v3.0.4 — AI coding assistant with XMem memory');
+if (args[0] === '--version' || args[0] === '-v' || args[0] === '-V') {
+  console.log('xcode v3.0.8 — AI coding assistant with XMem memory');
   process.exit(0);
 }
 
-if (command === '--help' || command === '-h') {
+if (args[0] === '--help' || args[0] === '-h') {
   console.log(`
 XCode - AI-powered coding assistant with XMem memory
 
-Usage: xcode [options] [command]
+Usage: xcode [options]
 
 Options:
-  -v, --version     Show version number
-  -h, --help        Show help
-  --model <model>   Start with specific model (e.g., gemini-2.5-pro, kimi-k2.5)
+  -v, --version          Show version
+  -h, --help             Show this help
+  --model <name>         Choose model: gemini-2.5-pro, kimi-k2.5, deepseek-v3.2
+  --openrouter           Force OpenRouter as provider
 
-Commands:
-  (none)            Start interactive session
-
-Environment Variables:
-  OPENROUTER_API_KEY      OpenRouter API key (optional, has default)
-  XMEM_API_URL           XMem memory server URL (default: http://localhost:8000)
+Environment:
   ANTHROPIC_API_KEY      Anthropic API key (for Claude models)
-
-Examples:
-  xcode                                    # Start with default model
-  xcode --model gemini-2.5-pro            # Use Gemini via OpenRouter
-  xcode --model kimi-k2.5                 # Use Kimi via OpenRouter
+  OPENROUTER_API_KEY     OpenRouter API key (optional, default provided)
+  XMEM_API_URL           XMem server URL (default: http://localhost:8000)
 `);
   process.exit(0);
 }
 
-// Check for model argument
-const modelIndex = args.indexOf('--model');
-if (modelIndex !== -1 && args[modelIndex + 1]) {
-  const model = args[modelIndex + 1];
+// Model / provider flags
+const modelIdx = args.indexOf('--model');
+if (modelIdx !== -1 && args[modelIdx + 1]) {
+  const model = args[modelIdx + 1];
   process.env.ANTHROPIC_MODEL = model;
-  
-  // If using OpenRouter models, auto-enable OpenRouter
-  const openRouterModels = ['kimi', 'deepseek', 'gemini', 'moonshot', 'google/gemini'];
-  if (openRouterModels.some(m => model.toLowerCase().includes(m.toLowerCase()))) {
+  const orModels = ['kimi', 'deepseek', 'gemini', 'moonshot', 'google/'];
+  if (orModels.some(m => model.toLowerCase().includes(m.toLowerCase()))) {
     process.env.CLAUDE_CODE_USE_OPENROUTER = 'true';
   }
 }
-
-// Check for explicit OpenRouter flag
 if (args.includes('--openrouter')) {
   process.env.CLAUDE_CODE_USE_OPENROUTER = 'true';
 }
 
-// Run the main application
-const runtime = getRuntime();
-
-if (runtime === 'bun') {
-  // Use Bun - it handles TypeScript natively
-  const child = spawn('bun', ['run', mainScript, ...args], {
-    cwd: projectRoot,
-    stdio: 'inherit',
-    env: process.env,
-  });
-  
-  child.on('exit', (code) => {
-    process.exit(code || 0);
-  });
-} else {
-  // Use Node with ts-node or tsx
-  // First check if tsx is installed globally or locally
-  let tsxPath;
-  try {
-    // Try local tsx first
-    tsxPath = require.resolve('tsx/dist/cli.mjs', { paths: [projectRoot] });
-  } catch {
-    try {
-      // Try global tsx
-      tsxPath = require.resolve('tsx/dist/cli.mjs');
-    } catch {
-      // Fallback to npx tsx
-      tsxPath = null;
-    }
-  }
-  
-  let child;
-  const hasHook = fs.existsSync(bunBundleHook);
-
-  if (tsxPath) {
-    // Use direct tsx path with bun:bundle shim
-    const nodeArgs = hasHook ? ['--require', bunBundleHook, tsxPath, mainScript] : [tsxPath, mainScript];
-    child = spawn('node', [...nodeArgs, ...args], {
-      cwd: projectRoot,
-      stdio: 'inherit',
-      env: process.env,
-    });
+// ── find / install Bun, then run ──────────────────────────────────────────────
+
+let bun = bunBinPath();
+if (!bun) {
+  bun = installBun();
+}
+
+const child = spawn(bun, ['run', mainScript, ...args], {
+  cwd: projectRoot,
+  stdio: 'inherit',
+  env: process.env,
+});
+
+child.on('exit', code => process.exit(code ?? 0));
+child.on('error', err => {
+  if (err.code === 'ENOENT') {
+    console.error('\n❌ Bun not found at: ' + bun);
+    console.error('Please run: curl -fsSL https://bun.sh/install | bash && xcode');
   } else {
-    // Fallback to npx
-    const npxArgs = hasHook ? ['--node-options', `--require ${bunBundleHook}`, 'tsx'] : ['tsx'];
-    child = spawn('npx', [...npxArgs, mainScript, ...args], {
-      cwd: projectRoot,
-      stdio: 'inherit',
-      env: process.env,
-    });
+    console.error('\n❌ Failed to start XCode:', err.message);
   }
-  
-  child.on('exit', (code) => {
-    process.exit(code || 0);
-  });
-  
-  child.on('error', (err) => {
-    console.error('❌ Failed to start XCode:', err.message);
-    console.error('');
-    console.error('Please ensure tsx is installed:');
-    console.error('  npm install -g tsx');
-    console.error('');
-    console.error('Or use Bun instead:');
-    console.error('  curl -fsSL https://bun.sh/install | bash');
-    process.exit(1);
-  });
-}
+  process.exit(1);
+});

package/bun-bundle-hook.js

@@ -1,25 +1,46 @@
 /**
- * Node.js require hook to shim bun:bundle module
- * This must be loaded before any other modules via --require flag
+ * Node.js require hook to shim 'bun:bundle' for tsx/Node.js compatibility.
+ *
+ * Strategy:
+ *   1. Intercept Module._resolveFilename so 'bun:bundle' resolves to a
+ *      sentinel path (not a real file) instead of throwing MODULE_NOT_FOUND.
+ *   2. Pre-populate Module._cache with the shim exports under that sentinel
+ *      path, so Module._load finds it in cache and never tries to read a file.
+ *
+ * This works even when tsx wraps _resolveFilename after this hook is installed,
+ * because tsx calls the original _resolveFilename as a fallback.
+ *
+ * Loaded via --require before tsx.
  */
+if (!global.__bunBundleHookInstalled) {
+  global.__bunBundleHookInstalled = true;
 
-const Module = require('module');
-const path = require('path');
+  const Module = require('module');
 
-const originalResolveFilename = Module._resolveFilename;
+  // Use a sentinel that looks like an absolute path so tsx / Node accept it.
+  // It never needs to exist on disk because we pre-populate the cache.
+  const SENTINEL = '\0bun:bundle';
 
-// Store the project root
-const projectRoot = path.resolve(__dirname);
-
-Module._resolveFilename = function (request, parent, isMain, options) {
-  // Intercept bun:bundle imports
-  if (request === 'bun:bundle') {
-    // Redirect to our compatibility module
-    const compatPath = path.join(projectRoot, 'utils', 'bunBundleCompat.js');
-    return compatPath;
+  // feature() shim: in Node.js all DCE gates are off by default.
+  // Override via CLAUDE_CODE_FEATURE_<NAME>=1 if needed.
+  function feature(name) {
+    const key = 'CLAUDE_CODE_FEATURE_' + String(name).replace(/[^A-Za-z0-9]/g, '_').toUpperCase();
+    const v = process.env[key];
+    return v === '1' || v === 'true';
   }
 
-  return originalResolveFilename.call(this, request, parent, isMain, options);
-};
+  // Populate the module cache before tsx can intercept _load
+  const shimModule = new Module(SENTINEL, null);
+  shimModule.id = SENTINEL;
+  shimModule.filename = SENTINEL;
+  shimModule.loaded = true;
+  shimModule.exports = { feature };
+  Module._cache[SENTINEL] = shimModule;
 
-console.log('[XCode] Bun compatibility hook loaded');
+  // Intercept _resolveFilename so 'bun:bundle' maps to our sentinel
+  const originalResolve = Module._resolveFilename;
+  Module._resolveFilename = function (request, parent, isMain, options) {
+    if (request === 'bun:bundle') return SENTINEL;
+    return originalResolve.call(this, request, parent, isMain, options);
+  };
+}

package/bun-bundle-shim.ts

@@ -0,0 +1,12 @@
+/**
+ * Shim for Bun's `bun:bundle` module, used in Node.js via tsx path aliases.
+ * Provides a no-op `feature()` function since all Bun DCE gates default to false
+ * in Node.js (the guarded code blocks have their own Node.js fallbacks).
+ */
+
+export function feature(name: string): boolean {
+  // Allow opt-in via env var if ever needed
+  const key = `CLAUDE_CODE_FEATURE_${String(name).replace(/[^A-Za-z0-9]/g, '_').toUpperCase()}`;
+  const v = process.env[key];
+  return v === '1' || v === 'true';
+}

package/entrypoints/cli.tsx

@@ -1,26 +1,6 @@
 import '../macro'; // Import to set MACRO global before any other code
 
-// Conditional import for bun:bundle - only available in Bun runtime
-// eslint-disable-next-line custom-rules/no-top-level-side-effects
-declare const Bun: { version: string } | undefined;
-// eslint-disable-next-line custom-rules/no-top-level-side-effects
-const isBun = typeof Bun !== 'undefined' && typeof Bun.version === 'string';
-
-// Stub feature function for Node.js compatibility
-// eslint-disable-next-line custom-rules/no-top-level-side-effects
-function feature(name: string): boolean {
-  if (isBun) {
-    // Dynamic import for Bun - will only execute in Bun
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const bunBundle = require('bun:bundle');
-      return bunBundle.feature(name);
-    } catch {
-      return false;
-    }
-  }
-  return false;
-}
+import { feature } from 'bun:bundle'
 
 // Bugfix for corepack auto-pinning, which adds yarnpkg to peoples' package.jsons
 // eslint-disable-next-line custom-rules/no-top-level-side-effects
@@ -59,7 +39,7 @@ async function main(): Promise<void> {
   if (args.length === 1 && (args[0] === '--version' || args[0] === '-v' || args[0] === '-V')) {
     // MACRO.VERSION is inlined at build time
     // biome-ignore lint/suspicious/noConsole:: intentional console output
-    console.log(`xcode v3.0.4 — AI coding assistant with XMem memory`);
+    console.log(`xcode v3.0.8 — AI coding assistant with XMem memory`);
     return;
   }
 

package/macro.ts

@@ -1,7 +1,7 @@
 // Build-time macros - stubbed for development
 
 export const MACRO = {
-  VERSION: '3.0.4',
+  VERSION: '3.0.8',
   VERSION_CHANGELOG: '',
   NATIVE_PACKAGE_URL: '@anthropic-ai/claude-code-native',
   CLI_BIN_PATH: './cli.tsx',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xortex/xcode",
-  "version": "3.0.4",
+  "version": "3.0.8",
   "description": "XCode - AI-powered coding assistant with XMem long-term memory. Supports Claude, Gemini, Kimi, DeepSeek via OpenRouter.",
   "main": "main.tsx",
   "bin": {
@@ -16,7 +16,8 @@
     "main.tsx",
     "macro.ts",
     "bun-bundle-hook.js",
-    "utils/bunBundleCompat.ts",
+    "bun-bundle-shim.ts",
+    "tsconfig.json",
     "src/",
     "constants/",
     "utils/",
@@ -129,6 +130,7 @@
     "terminal-link": "^5.0.0",
     "terminal-size": "^4.0.1",
     "tree-kill": "^1.2.2",
+    "tsx": "^4.19.4",
     "usehooks-ts": "^3.1.1",
     "uuid": "^13.0.0",
     "widest-line": "^6.0.0",
@@ -143,6 +145,6 @@
     "@types/lodash-es": "^4.17.12",
     "@types/node": "^25.5.0",
     "@types/react": "^19.2.14",
-    "tsx": "^4.19.0"
+    "esbuild": "^0.28.0"
   }
 }

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "baseUrl": ".",
+    "paths": {
+      "src/*": ["./*"],
+      "bun:bundle": ["./bun-bundle-shim"]
+    }
+  }
+}

package/utils/bunBundleCompat.ts

@@ -1,44 +0,0 @@
-/**
- * Compatibility layer for bun:bundle module
- * Provides feature() function for both Bun and Node.js runtimes
- */
-
-// Detect if running in Bun
-// eslint-disable-next-line custom-rules/no-top-level-side-effects
-declare const Bun: { version: string } | undefined;
-// eslint-disable-next-line custom-rules/no-top-level-side-effects
-const isBunRuntime = typeof Bun !== 'undefined' && typeof Bun.version === 'string';
-
-/**
- * Check if a feature flag is enabled.
- * In Bun, this uses the native bun:bundle module.
- * In Node.js, this checks environment variables.
- */
-export function feature(name: string): boolean {
-  if (isBunRuntime) {
-    try {
-      // Dynamic require for Bun
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const bunBundle = require('bun:bundle');
-      return bunBundle.feature(name);
-    } catch {
-      return false;
-    }
-  }
-
-  // In Node.js, check for equivalent environment variable
-  // Features are typically controlled via CLAUDE_CODE_* env vars
-  const envVarName = name.replace(/([A-Z])/g, '_$1').toUpperCase();
-  const envValue = process.env[`CLAUDE_CODE_${envVarName}`] || process.env[envVarName];
-
-  if (envValue === '1' || envValue === 'true') {
-    return true;
-  }
-
-  // Default feature flags for Node.js
-  const defaultEnabled: Record<string, boolean> = {
-    // Add any features that should be enabled by default
-  };
-
-  return defaultEnabled[name] ?? false;
-}