@vibedx/vibekit 0.1.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedx/vibekit",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "A powerful CLI tool for managing development tickets and project workflows",
   "main": "index.js",
   "type": "module",
@@ -18,6 +18,7 @@
     "test:watch": "NODE_OPTIONS='--experimental-vm-modules' jest --watch",
     "test:coverage": "NODE_OPTIONS='--experimental-vm-modules' jest --coverage --detectOpenHandles",
     "test:cleanup": "rm -rf __temp__",
+    "test:e2e": "node scripts/e2e.js",
     "prepublishOnly": "echo 'Ready to publish'",
     "version": "git add -A && git commit -m 'chore: version bump'",
     "postversion": "git push && git push --tags"

package/src/commands/link/index.js

@@ -1,96 +1,26 @@
 import fs from 'fs';
 import path from 'path';
-import { createInterface } from 'readline';
+import { spawn } from 'child_process';
 import yaml from 'js-yaml';
 
-const SUPPORTED_PROVIDERS = {
-  'claude-code': 'Claude Code (Anthropic)'
-};
+const CLAUDE_CODE_INSTALL_URL = 'https://docs.anthropic.com/en/docs/claude-code';
+const CLAUDE_DETECT_TIMEOUT = 5000;
 
 /**
- * Create readline interface for user input
- */
-function createReadlineInterface() {
-  return createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-}
-
-/**
- * Prompt user for input with question
- */
-function askQuestion(rl, question) {
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      resolve(answer.trim());
-    });
-  });
-}
-
-/**
- * Prompt user for password/API key (hidden input)
- */
-function askSecretQuestion(rl, question) {
-  return new Promise((resolve) => {
-    process.stdout.write(question);
-    
-    // Use readline's built-in password functionality instead of raw mode
-    const stdin = process.stdin;
-    const originalMode = stdin.isTTY ? stdin.setRawMode : null;
-    
-    if (stdin.isTTY && originalMode) {
-      stdin.setRawMode(true);
-    }
-    
-    let input = '';
-    const onData = (buffer) => {
-      const char = buffer.toString('utf8');
-      const code = char.charCodeAt(0);
-      
-      if (code === 13 || code === 10) { // Enter key (CR or LF)
-        if (stdin.isTTY && originalMode) {
-          stdin.setRawMode(false);
-        }
-        stdin.removeListener('data', onData);
-        console.log(); // New line
-        resolve(input);
-      } else if (code === 127 || code === 8) { // Backspace/Delete
-        if (input.length > 0) {
-          input = input.slice(0, -1);
-          process.stdout.write('\b \b');
-        }
-      } else if (code === 3) { // Ctrl+C
-        if (stdin.isTTY && originalMode) {
-          stdin.setRawMode(false);
-        }
-        stdin.removeListener('data', onData);
-        console.log('\n❌ Cancelled');
-        process.exit(0);
-      } else if (code >= 32 && code <= 126) { // Printable ASCII characters
-        input += char;
-        process.stdout.write('*');
-      }
-    };
-    
-    stdin.on('data', onData);
-  });
-}
-
-/**
- * Load existing config.yml
+ * Load existing .vibe/config.yml
+ * @returns {Object} Parsed config object
  */
 function loadConfig() {
   const configPath = path.join(process.cwd(), '.vibe', 'config.yml');
-  
+
   if (!fs.existsSync(configPath)) {
     console.error('❌ No .vibe/config.yml found. Run "vibe init" first.');
     process.exit(1);
   }
-  
+
   try {
-    const configContent = fs.readFileSync(configPath, 'utf8');
-    return yaml.load(configContent);
+    const content = fs.readFileSync(configPath, 'utf8');
+    return yaml.load(content);
   } catch (error) {
     console.error('❌ Error reading config.yml:', error.message);
     process.exit(1);
@@ -98,17 +28,15 @@ function loadConfig() {
 }
 
 /**
- * Save updated config.yml (without sensitive data)
+ * Save updated config to .vibe/config.yml (no sensitive data stored)
+ * @param {Object} config - Config object to persist
+ * @returns {boolean} True on success
  */
 function saveConfig(config) {
   const configPath = path.join(process.cwd(), '.vibe', 'config.yml');
-  
+
   try {
-    const yamlContent = yaml.dump(config, { 
-      indent: 2,
-      lineWidth: -1,
-      noRefs: true
-    });
+    const yamlContent = yaml.dump(config, { indent: 2, lineWidth: -1, noRefs: true });
     fs.writeFileSync(configPath, yamlContent, 'utf8');
     return true;
   } catch (error) {
@@ -118,278 +46,136 @@ function saveConfig(config) {
 }
 
 /**
- * Check if .env file exists and contains ANTHROPIC_API_KEY
+ * Check if the Claude Code CLI is installed and accessible
+ * @returns {Promise<{ installed: boolean, version: string | null }>}
  */
-function checkEnvFile() {
-  const envPath = path.join(process.cwd(), '.env');
-  
-  if (!fs.existsSync(envPath)) {
-    return { exists: false, hasKey: false };
-  }
-  
-  try {
-    const envContent = fs.readFileSync(envPath, 'utf8');
-    const hasKey = envContent.includes('ANTHROPIC_API_KEY=');
-    return { exists: true, hasKey };
-  } catch (error) {
-    return { exists: false, hasKey: false };
-  }
-}
+function detectClaudeCode() {
+  return new Promise((resolve) => {
+    let stdout = '';
 
-/**
- * Create or update .env file with API key
- */
-async function createEnvFile(rl) {
-  const envPath = path.join(process.cwd(), '.env');
-  const envInfo = checkEnvFile();
-  
-  console.log('\n📝 Setting up .env file for secure API key storage');
-  
-  if (envInfo.exists && envInfo.hasKey) {
-    console.log('⚠️  .env file already contains ANTHROPIC_API_KEY');
-    const overwrite = await askQuestion(rl, '? Update the existing API key? (y/n): ');
-    if (overwrite.toLowerCase() !== 'y' && overwrite.toLowerCase() !== 'yes') {
-      return false;
-    }
-  }
-  
-  const apiKey = await askSecretQuestion(rl, '? Enter your Claude API key: ');
-  
-  if (!apiKey) {
-    console.log('❌ API key is required.');
-    return false;
-  }
-  
-  // Validate API key first
-  console.log('🔍 Validating API key...');
-  const validation = validateClaudeApiKey(apiKey);
-  
-  if (!validation.valid) {
-    console.log(`❌ ${validation.error}`);
-    return false;
-  }
-  
-  try {
-    let envContent = '';
-    
-    if (envInfo.exists) {
-      // Read existing .env and update/add ANTHROPIC_API_KEY
-      envContent = fs.readFileSync(envPath, 'utf8');
-      
-      if (envInfo.hasKey) {
-        // Replace existing key
-        envContent = envContent.replace(/ANTHROPIC_API_KEY=.*$/m, `ANTHROPIC_API_KEY=${apiKey}`);
+    const child = spawn('claude', ['--version'], {
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      resolve({ installed: false, version: null });
+    }, CLAUDE_DETECT_TIMEOUT);
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code === 0) {
+        resolve({ installed: true, version: stdout.trim() || null });
       } else {
-        // Add new key
-        envContent += envContent.endsWith('\n') ? '' : '\n';
-        envContent += `ANTHROPIC_API_KEY=${apiKey}\n`;
+        resolve({ installed: false, version: null });
       }
-    } else {
-      // Create new .env file
-      envContent = `# Environment variables for VibeKit
-ANTHROPIC_API_KEY=${apiKey}
-`;
-    }
-    
-    fs.writeFileSync(envPath, envContent, 'utf8');
-    console.log('✅ API key saved to .env file');
-    console.log('🔒 Make sure .env is in your .gitignore');
-    
-    // Update the current process environment
-    process.env.ANTHROPIC_API_KEY = apiKey;
-    
-    return true;
-  } catch (error) {
-    console.error('❌ Error creating .env file:', error.message);
-    return false;
-  }
+    });
+
+    child.on('error', () => {
+      clearTimeout(timer);
+      resolve({ installed: false, version: null });
+    });
+  });
 }
 
 /**
- * Create AI instructions for Claude Code from template
+ * Create AI workflow instructions from the assets template
+ * @returns {Promise<boolean>} True on success
  */
 async function createAiInstructions() {
   try {
-    // Create .context/instructions directory
     const instructionsDir = path.join(process.cwd(), '.context', 'instructions');
+
     if (!fs.existsSync(instructionsDir)) {
       fs.mkdirSync(instructionsDir, { recursive: true });
     }
-    
-    // Copy claude instructions from assets template
+
     const templatePath = path.join(process.cwd(), 'assets', 'instructions', 'claude.md');
-    const claudeInstructionsPath = path.join(instructionsDir, 'claude.md');
-    
+    const outputPath = path.join(instructionsDir, 'claude.md');
+
     if (fs.existsSync(templatePath)) {
-      const templateContent = fs.readFileSync(templatePath, 'utf8');
-      fs.writeFileSync(claudeInstructionsPath, templateContent, 'utf8');
-      console.log('📄 Created .context/instructions/claude.md from template');
+      fs.writeFileSync(outputPath, fs.readFileSync(templatePath, 'utf8'), 'utf8');
     } else {
-      console.warn('⚠️  Template not found, creating basic instructions');
-      const basicContent = `# VibeKit Instructions for Claude
+      fs.writeFileSync(outputPath, buildFallbackInstructions(), 'utf8');
+    }
 
-This project uses VibeKit for organized development.
+    console.log('📄 Created .context/instructions/claude.md');
+    return true;
+  } catch (error) {
+    console.warn('⚠️  Could not create AI instructions:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Fallback instructions if the assets template is missing
+ * @returns {string} Markdown instruction content
+ */
+function buildFallbackInstructions() {
+  return `# VibeKit Instructions for Claude
+
+This project uses VibeKit for organised, ticket-driven development.
 
 ## Primary Rule: Always Work Through Tickets
-1. Create ticket first: \`vibe new\`
+1. Create a ticket first: \`vibe new\`
 2. Start working: \`vibe start <ticket-id>\`
 3. Close when done: \`vibe close <ticket-id>\`
 
 For detailed instructions, see the VibeKit documentation.
 `;
-      fs.writeFileSync(claudeInstructionsPath, basicContent, 'utf8');
-    }
-    
-    // Create a README for the .context/instructions folder
-    const readmePath = path.join(instructionsDir, 'README.md');
-    const readmeContent = `# AI Instructions
-
-This folder contains instructions for different AI coding assistants.
-
-## Files
-- \`claude.md\` - Instructions for Claude Code (Anthropic)
-- \`codex.md\` - Instructions for OpenAI Codex (coming soon)
-
-## Important Notes
-- These files are automatically read by AI assistants
-- Only modify if you understand how AI instructions work
-- Changes affect how AI assistants interact with this project
-- Maintained by VibeKit for consistent development workflow
-
-## Current Status
-- ✅ Claude Code - Active and configured
-- 🚧 OpenAI Codex - Coming soon
-`;
-
-    fs.writeFileSync(readmePath, readmeContent, 'utf8');
-    console.log('📄 Created .context/instructions/README.md with folder documentation');
-    
-    return true;
-  } catch (error) {
-    console.warn('⚠️  Could not create AI instructions:', error.message);
-    return false;
-  }
 }
 
 /**
- * Validate Claude API key format
+ * Print install instructions for Claude Code CLI
  */
-function validateClaudeApiKey(apiKey) {
-  if (!apiKey || typeof apiKey !== 'string') {
-    return { valid: false, error: 'API key is required' };
-  }
-  
-  if (!apiKey.startsWith('sk-ant-api')) {
-    return { valid: false, error: 'Invalid Claude API key format' };
-  }
-  
-  return { valid: true };
+function printInstallInstructions() {
+  console.log('\n📦 Install Claude Code to continue:\n');
+  console.log('   npm install -g @anthropic-ai/claude-code');
+  console.log(`\n📖 Documentation: ${CLAUDE_CODE_INSTALL_URL}`);
+  console.log('\nOnce installed, run "vibe link" again.\n');
 }
 
 /**
- * Main link command implementation
+ * Main link command — detects Claude Code CLI and configures the project
  */
 async function linkCommand() {
-  console.log('🔗 VibeKit AI Provider Setup\n');
-  
+  console.log('🔗 Linking VibeKit to Claude Code\n');
+
   const config = loadConfig();
-  const rl = createReadlineInterface();
-  
-  try {
-    // Check for environment variable first
-    const envApiKey = process.env.ANTHROPIC_API_KEY;
-    if (envApiKey) {
-      console.log('🔍 Found ANTHROPIC_API_KEY in environment variables');
-      const useEnvKey = await askQuestion(rl, '? Use this API key? (y/n): ');
-      
-      if (useEnvKey.toLowerCase() === 'y' || useEnvKey.toLowerCase() === 'yes') {
-        console.log('🔍 Validating API key...');
-        const validation = validateClaudeApiKey(envApiKey);
-        
-        if (validation.valid) {
-          // Update config (never store API key in config)
-          config.ai = {
-            ...config.ai,
-            provider: 'claude-code',
-            enabled: true
-          };
-          
-          if (saveConfig(config)) {
-            console.log('✅ Environment API key validated!');
-            console.log('🔗 Ready for ticket refinement!');
-            console.log(`\n📝 Configuration updated:`);
-            console.log(`   Provider: ${SUPPORTED_PROVIDERS['claude-code']}`);
-            console.log('   Source: Environment variable (ANTHROPIC_API_KEY)');
-            console.log('\n💡 You can now use AI features like "vibe refine"');
-            
-            // Create AI instructions documentation
-            await createAiInstructions();
-          } else {
-            console.log('❌ Failed to save configuration.');
-          }
-          rl.close();
-          return;
-        } else {
-          console.log(`❌ Environment API key validation failed: ${validation.error}`);
-          console.log('Continuing with setup...\n');
-        }
-      }
-    }
-    
-    // No environment variable found or user chose not to use it
-    console.log('\n🔑 API Key Setup Required');
-    console.log('To use Claude Code, you need to set up your API key.');
-    console.log('\nChoose your preferred method:');
-    console.log('1. Export environment variable (recommended)');
-    console.log('2. Create .env file');
-    console.log();
-    
-    const methodChoice = await askQuestion(rl, '? Choose setup method (1-2): ');
-    
-    if (methodChoice === '1') {
-      // Guide user to export environment variable
-      console.log('\n📋 To set up environment variable:');
-      console.log('\n🔹 For current session:');
-      console.log('   export ANTHROPIC_API_KEY="your-api-key-here"');
-      console.log('\n🔹 For permanent setup (add to ~/.bashrc or ~/.zshrc):');
-      console.log('   echo \'export ANTHROPIC_API_KEY="your-api-key-here"\' >> ~/.bashrc');
-      console.log('\n💡 After setting the environment variable, run "vibe link" again.');
-      rl.close();
-      return;
-    } else if (methodChoice === '2') {
-      // Create .env file
-      const envCreated = await createEnvFile(rl);
-      
-      if (envCreated) {
-        // Update config 
-        config.ai = {
-          ...config.ai,
-          provider: 'claude-code',
-          enabled: true
-        };
-        
-        if (saveConfig(config)) {
-          console.log('🔗 Ready for ticket refinement!');
-          console.log(`\n📝 Configuration updated:`);
-          console.log(`   Provider: ${SUPPORTED_PROVIDERS['claude-code']}`);
-          console.log('   Source: .env file');
-          console.log('\n💡 You can now use AI features like "vibe refine"');
-          
-          // Create AI instructions documentation
-          await createAiInstructions();
-        } else {
-          console.log('❌ Failed to save configuration.');
-        }
-      }
-    } else {
-      console.log('❌ Invalid choice. Please run the command again.');
-    }
-    
-  } catch (error) {
-    console.error('❌ Error during setup:', error.message);
-  } finally {
-    rl.close();
+
+  console.log('🔍 Detecting Claude Code CLI...');
+  const { installed, version } = await detectClaudeCode();
+
+  if (!installed) {
+    console.error('❌ Claude Code CLI not found.');
+    printInstallInstructions();
+    process.exit(1);
+  }
+
+  const versionLabel = version ? ` (${version})` : '';
+  console.log(`✅ Claude Code detected${versionLabel}`);
+
+  config.ai = {
+    ...config.ai,
+    enabled: true,
+    provider: 'claude-code',
+  };
+
+  if (!saveConfig(config)) {
+    console.error('❌ Failed to save configuration.');
+    process.exit(1);
   }
+
+  console.log('✅ Configuration updated');
+
+  await createAiInstructions();
+
+  console.log('\n🎉 Claude Code linked successfully!');
+  console.log('   You can now use AI features like "vibe refine"\n');
 }
 
-export default linkCommand;
+export default linkCommand;

package/src/commands/refine/index.js

@@ -1,14 +1,11 @@
 import fs from 'fs';
 import path from 'path';
+import { spawn } from 'child_process';
 import yaml from 'js-yaml';
 import { resolveTicketId, parseTicket, updateTicket } from '../../utils/ticket.js';
 import { select, spinner, input, logger } from '../../utils/cli.js';
 import { arrowSelect } from '../../utils/arrow-select.js';
 
-// Configuration constants
-const CLAUDE_SDK_TIMEOUT = 30000;
-const ENHANCEMENT_MODEL = 'claude-3-5-sonnet-latest';
-
 /**
  * Load VibeKit configuration
  * @returns {Object} Configuration object
@@ -36,92 +33,20 @@ function loadConfig() {
 }
 
 /**
- * Check if Claude Code SDK is available
- * @returns {Promise<boolean>} True if SDK is available
+ * Check if AI is configured in .vibe/config.yml
+ * @returns {Object} AI configuration status
  */
-async function checkClaudeCodeSDK() {
-  try {
-    const { spawn } = await import('child_process');
-    
-    return new Promise((resolve) => {
-      const child = spawn('claude', ['--version'], { 
-        stdio: 'pipe',
-        timeout: 5000
-      });
-      
-      child.on('close', (code) => {
-        resolve(code === 0);
-      });
-      
-      child.on('error', () => {
-        resolve(false);
-      });
-      
-      // Timeout fallback
-      const timeout = setTimeout(() => {
-        try {
-          child.kill('SIGTERM');
-        } catch (killError) {
-          // Ignore kill errors
-        }
-        resolve(false);
-      }, 5000);
-      
-      child.on('exit', () => {
-        clearTimeout(timeout);
-      });
-    });
-  } catch (error) {
-    return false;
-  }
-}
+function checkAiConfiguration() {
+  const config = loadConfig();
 
-/**
- * Check if AI is configured and Claude Code SDK is available
- * @returns {Promise<Object>} AI configuration status
- * @throws {Error} If configuration check fails
- */
-async function checkAiConfiguration() {
-  try {
-    const config = loadConfig();
-    
-    // Check if AI is enabled in config
-    if (!config.ai || !config.ai.enabled || config.ai.provider === 'none') {
-      return { 
-        configured: false, 
-        needsSetup: false,
-        reason: 'AI is not enabled in configuration'
-      };
-    }
-    
-    // Check for Claude Code SDK availability
-    const sdkAvailable = await checkClaudeCodeSDK();
-    if (sdkAvailable) {
-      return { configured: true };
-    }
-    
-    // SDK not available - needs installation
-    return { 
-      configured: false, 
-      needsSetup: true,
-      reason: 'Claude Code SDK not found'
+  if (!config.ai?.enabled || config.ai?.provider === 'none') {
+    return {
+      configured: false,
+      reason: 'AI is not enabled. Run "vibe link" first.'
     };
-  } catch (error) {
-    throw new Error(`Failed to check AI configuration: ${error.message}`);
   }
-}
 
-/**
- * Show Claude Code SDK installation information
- * @returns {void}
- */
-function showClaudeCodeInstallation() {
-  logger.error('Claude Code SDK not found.');
-  logger.info('VibeKit refine requires Claude Code SDK to enhance tickets.');
-  console.log('\nTo install Claude Code SDK, run:');
-  console.log('  npm install -g @anthropic-ai/claude-code');
-  console.log('\nOr visit: https://docs.anthropic.com/en/docs/claude-code');
-  logger.tip('After installation, run this command again.');
+  return { configured: true };
 }
 
 
@@ -225,125 +150,118 @@ Response must be valid JSON only.`;
 }
 
 /**
- * Execute Claude Code SDK command safely
+ * Extract a JSON object from Claude's raw text response.
+ * Handles plain JSON, markdown code blocks, and mixed content.
+ * @param {string} text - Raw text from Claude
+ * @returns {string} Validated JSON string
+ * @throws {Error} If no valid JSON object can be found
+ */
+function extractJsonFromResponse(text) {
+  const cleaned = text.trim();
+
+  // 1. Direct parse — Claude responded with pure JSON
+  try {
+    JSON.parse(cleaned);
+    return cleaned;
+  } catch { /* fall through */ }
+
+  // 2. Markdown code block — ```json ... ``` or ``` ... ```
+  const codeBlockMatch = cleaned.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  if (codeBlockMatch) {
+    const inner = codeBlockMatch[1].trim();
+    try {
+      JSON.parse(inner);
+      return inner;
+    } catch { /* fall through */ }
+  }
+
+  // 3. Loose extraction — grab first {...} block
+  const objMatch = cleaned.match(/\{[\s\S]*\}/);
+  if (objMatch) {
+    try {
+      JSON.parse(objMatch[0]);
+      return objMatch[0];
+    } catch { /* fall through */ }
+  }
+
+  throw new Error('No valid JSON object found in Claude response');
+}
+
+/**
+ * Parse the JSON envelope returned by `claude --print --output-format json`.
+ * Throws if the response signals an error or contains no result text.
+ * @param {string} raw - Raw stdout from the claude subprocess
+ * @returns {string} Claude's text result
+ * @throws {Error} If the envelope signals an error or cannot be parsed
+ */
+function parseClaudeEnvelope(raw) {
+  let envelope;
+  try {
+    envelope = JSON.parse(raw.trim());
+  } catch {
+    throw new Error('Claude returned non-JSON output');
+  }
+
+  if (envelope.is_error) {
+    throw new Error(envelope.result || 'Claude reported an error');
+  }
+
+  const text = envelope.result ?? '';
+  if (!text.trim()) {
+    throw new Error('Claude returned an empty result');
+  }
+
+  return text;
+}
+
+/**
+ * Send a prompt to Claude via `claude --print` and return the JSON response string.
+ * Uses the native Claude Code CLI — no API key management required.
  * @param {string} prompt - The prompt to send to Claude
- * @returns {Promise<string>} Claude's response
- * @throws {Error} If execution fails
+ * @returns {Promise<string>} Validated JSON string from Claude's result
+ * @throws {Error} If the subprocess fails or response contains no valid JSON
  */
 async function executeClaudeCommand(prompt) {
   if (typeof prompt !== 'string' || !prompt.trim()) {
     throw new Error('Prompt must be a non-empty string');
   }
-  
-  const { writeFileSync, unlinkSync } = await import('fs');
-  const { exec } = await import('child_process');
-  const { tmpdir } = await import('os');
-  const { join } = await import('path');
-  
+
   return new Promise((resolve, reject) => {
-    const tempFile = join(tmpdir(), `vibe-prompt-${Date.now()}-${Math.random().toString(36).substring(7)}.txt`);
-    let childProcess = null;
-    
-    // Cleanup function
-    const cleanup = () => {
-      try {
-        if (fs.existsSync(tempFile)) {
-          unlinkSync(tempFile);
-        }
-      } catch (cleanupError) {
-        // Ignore cleanup errors
-      }
-      
-      if (childProcess) {
-        try {
-          childProcess.kill('SIGTERM');
-        } catch (killError) {
-          // Ignore kill errors
-        }
-      }
-    };
-    
-    try {
-      // Write prompt to temporary file
-      writeFileSync(tempFile, prompt, 'utf8');
-    } catch (writeError) {
-      reject(new Error(`Failed to write prompt file: ${writeError.message}`));
-      return;
-    }
-    
-    const command = `cat "${tempFile}" | claude --print --output-format json --model ${ENHANCEMENT_MODEL}`;
-    
-    childProcess = exec(command, {
-      timeout: CLAUDE_SDK_TIMEOUT,
-      maxBuffer: 2 * 1024 * 1024, // 2MB buffer
-      killSignal: 'SIGTERM'
-    }, (error, stdout, stderr) => {
-      cleanup();
-      
-      if (error) {
-        // Handle specific error types
-        if (error.code === 'ENOENT') {
-          reject(new Error('Claude Code SDK not found. Please install it first.'));
-        } else if (error.code === 'EACCES') {
-          reject(new Error('Permission denied accessing Claude Code SDK.'));
-        } else if (error.signal === 'SIGTERM') {
-          reject(new Error('Claude SDK operation timed out.'));
-        } else {
-          reject(new Error(`Claude Code SDK failed: ${error.message}`));
-        }
-        return;
-      }
-      
-      // Check for stderr output
-      if (stderr && stderr.trim()) {
-        console.warn(`⚠️  Claude SDK warning: ${stderr.trim()}`);
-      }
-      
-      // Validate stdout
-      if (!stdout || stdout.trim() === '') {
-        reject(new Error('Claude SDK returned empty response'));
+    // Create environment without API key — use native Claude Code authentication only
+    const env = { ...process.env };
+    delete env.ANTHROPIC_API_KEY;
+
+    const child = spawn('claude', ['--print', '--output-format', 'json'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+
+    child.on('error', (err) => {
+      reject(new Error(`Failed to spawn Claude: ${err.message}`));
+    });
+
+    child.on('close', (code) => {
+      if (!stdout.trim()) {
+        reject(new Error(stderr.trim() || `Claude exited with code ${code}`));
         return;
       }
-      
+
       try {
-        // Try to parse as JSON first
-        const sdkResponse = JSON.parse(stdout.trim());
-        const result = sdkResponse.result || sdkResponse.content || sdkResponse;
-        
-        if (typeof result === 'string') {
-          resolve(result);
-        } else {
-          resolve(JSON.stringify(result));
-        }
-      } catch (parseError) {
-        // If JSON parsing fails, try to extract JSON from response
-        const jsonMatch = stdout.match(/{[\s\S]*}/);
-        if (jsonMatch) {
-          try {
-            JSON.parse(jsonMatch[0]); // Validate JSON
-            resolve(jsonMatch[0]);
-          } catch (secondParseError) {
-            reject(new Error(`Failed to parse Claude SDK response as JSON: ${secondParseError.message}`));
-          }
-        } else {
-          reject(new Error('Claude SDK response is not valid JSON'));
-        }
+        const text = parseClaudeEnvelope(stdout);
+        resolve(extractJsonFromResponse(text));
+      } catch (err) {
+        reject(err);
       }
     });
-    
-    // Handle process errors
-    childProcess.on('error', (error) => {
-      cleanup();
-      reject(new Error(`Failed to run Claude Code SDK: ${error.message}`));
-    });
-    
-    // Set up timeout handler
-    setTimeout(() => {
-      if (childProcess && !childProcess.killed) {
-        cleanup();
-        reject(new Error('Claude SDK operation timed out'));
-      }
-    }, CLAUDE_SDK_TIMEOUT + 1000);
+
+    child.stdin.write(prompt, 'utf8');
+    child.stdin.end();
   });
 }
 
@@ -646,14 +564,10 @@ async function refineCommand(args, options = {}) {
     logger.step(`Analyzing ticket ${ticketInput}...`);
     
     // Check AI configuration
-    const aiStatus = await checkAiConfiguration();
+    const aiStatus = checkAiConfiguration();
     if (!aiStatus.configured) {
-      if (aiStatus.needsSetup) {
-        showClaudeCodeInstallation();
-      } else {
-        logger.error('AI is not enabled in config. Run "vibe link" first.');
-      }
-      throw new Error(aiStatus.reason || 'AI configuration check failed');
+      logger.error(aiStatus.reason);
+      return;
     }
   
     // Resolve ticket ID
@@ -686,18 +600,8 @@ async function refineCommand(args, options = {}) {
       
     } catch (error) {
       loadingSpinner.fail('Enhancement failed');
-      
-      if (error.message.includes('Claude Code SDK failed')) {
-        logger.error('AI enhancement service is unavailable.');
-        logger.info('This could be due to:');
-        console.log('   • Claude Code SDK not installed or configured');
-        console.log('   • Network connectivity issues');
-        console.log('   • API rate limits or authentication problems');
-        logger.tip('You can still view and edit the ticket manually.');
-      } else {
-        logger.error('Failed to enhance ticket.');
-        logger.tip('Please check your Claude Code SDK installation and try again.');
-      }
+      logger.error(error.message);
+      logger.tip('You can still view and edit the ticket manually.');
       return;
     }