natureco-cli 2.23.29 → 2.23.30

package/src/commands/oc-path.js

@@ -0,0 +1,200 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+function normalizeNcPath(uri) {
+  if (!uri) return null;
+
+  const str = uri.trim();
+
+  if (str.startsWith('nc://')) return str.slice(5);
+  if (str.startsWith('natureco://')) return str.slice(10);
+
+  return str;
+}
+
+function resolveNcPath(ncPath) {
+  if (!ncPath) return null;
+
+  const parts = ncPath.split('/').filter(Boolean);
+  const scope = parts[0];
+  const rest = parts.slice(1);
+
+  if (scope === 'workspace' || scope === 'w') {
+    return { type: 'workspace', path: rest.join('/') || '.', description: 'Workspace path' };
+  }
+
+  if (scope === 'home' || scope === 'h') {
+    return { type: 'home', path: path.join(os.homedir(), ...rest), description: 'Home directory' };
+  }
+
+  if (scope === 'config' || scope === 'c') {
+    const configDir = path.join(os.homedir(), '.natureco');
+    return { type: 'config', path: rest.length ? path.join(configDir, ...rest) : configDir, description: 'Config directory' };
+  }
+
+  if (scope === 'tmp' || scope === 't') {
+    return { type: 'tmp', path: path.join(os.tmpdir(), ...rest), description: 'Temp directory' };
+  }
+
+  if (scope === 'tools' || scope === 'tool') {
+    const toolsDir = path.join(__dirname, '..', 'tools');
+    return { type: 'tools', path: path.join(toolsDir, ...rest), description: 'Tools directory' };
+  }
+
+  if (scope === 'commands' || scope === 'cmd') {
+    const cmdsDir = path.join(__dirname, '..', 'commands');
+    return { type: 'commands', path: path.join(cmdsDir, ...rest), description: 'Commands directory' };
+  }
+
+  if (scope === 'project' || scope === 'p') {
+    return { type: 'project', path: rest.join('/') || '.', description: 'Project path (CWD)' };
+  }
+
+  if (scope === 'skills' || scope === 's') {
+    const skillsDir = path.join(__dirname, '..', '..', 'skills');
+    return { type: 'skills', path: path.join(skillsDir, ...rest), description: 'Skills directory' };
+  }
+
+  if (scope === 'data' || scope === 'd') {
+    const dataDir = path.join(os.homedir(), '.natureco', 'data');
+    return { type: 'data', path: rest.length ? path.join(dataDir, ...rest) : dataDir, description: 'Data directory' };
+  }
+
+  return { type: 'unknown', path: ncPath, description: 'Unresolved path' };
+}
+
+function ocPath(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'resolve') return resolvePath(params.join('/'));
+  if (action === 'list') return listScopes();
+  if (action === 'cat') return catFile(params.join('/'));
+  if (action === 'ls') return lsPath(params.join('/'));
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco oc-path [resolve|list|cat|ls] <path>\n'));
+  process.exit(1);
+}
+
+function resolvePath(uri) {
+  const ncPath = normalizeNcPath(uri);
+  if (!ncPath) {
+    console.log(chalk.red('\n  ❌ Path gerekli\n'));
+    console.log(chalk.cyan('    natureco oc-path resolve nc://config\n'));
+    process.exit(1);
+  }
+
+  const resolved = resolveNcPath(ncPath);
+  if (!resolved) {
+    console.log(chalk.red(`\n  ❌ Çözümlenemedi: ${ncPath}\n`));
+    process.exit(1);
+  }
+
+  const exists = fs.existsSync(resolved.path);
+
+  console.log(chalk.cyan('\n  📍 nc:// Path Resolution\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Scope:')}       ${chalk.cyan(resolved.type)}`);
+  console.log(`  ${chalk.white('Path:')}        ${chalk.white(resolved.path)}`);
+  console.log(`  ${chalk.white('Description:')} ${chalk.gray(resolved.description)}`);
+  console.log(`  ${chalk.white('Exists:')}      ${exists ? chalk.green('Yes') : chalk.red('No')}`);
+  console.log();
+}
+
+function listScopes() {
+  console.log(chalk.cyan('\n  📍 nc:// Path Scopes\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  const scopes = [
+    { alias: 'w', scope: 'workspace', desc: 'CWD altındaki dosyalar' },
+    { alias: 'p', scope: 'project', desc: 'Proje kökü (CWD)' },
+    { alias: 'h', scope: 'home', desc: 'Kullanıcı ana dizini (~)' },
+    { alias: 'c', scope: 'config', desc: '~/.natureco yapılandırma' },
+    { alias: 'd', scope: 'data', desc: '~/.natureco/data veri dizini' },
+    { alias: 't', scope: 'tmp', desc: 'Geçici dizin' },
+    { alias: 's', scope: 'skills', desc: 'Skill dizini' },
+    { alias: 'tool', scope: 'tools', desc: 'Araçlar dizini' },
+    { alias: 'cmd', scope: 'commands', desc: 'Komutlar dizini' }
+  ];
+
+  for (const s of scopes) {
+    console.log(`  ${chalk.cyan(`nc://${s.scope}`)} ${chalk.gray(`(${s.alias})`)} ${chalk.white('-')} ${chalk.gray(s.desc)}`);
+  }
+
+  console.log(chalk.gray('\n  Examples:'));
+  console.log(chalk.cyan('    natureco oc-path resolve nc://config'));
+  console.log(chalk.cyan('    natureco oc-path ls nc://tools'));
+  console.log(chalk.cyan('    natureco oc-path cat nc://c/settings.json'));
+  console.log();
+}
+
+function catFile(uri) {
+  const ncPath = normalizeNcPath(uri);
+  if (!ncPath) {
+    console.log(chalk.red('\n  ❌ Path gerekli\n'));
+    process.exit(1);
+  }
+
+  const resolved = resolveNcPath(ncPath);
+  if (!resolved) {
+    console.log(chalk.red(`\n  ❌ Çözümlenemedi: ${ncPath}\n`));
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(resolved.path)) {
+    console.log(chalk.red(`\n  ❌ Dosya bulunamadı: ${resolved.path}\n`));
+    process.exit(1);
+  }
+
+  const stat = fs.statSync(resolved.path);
+  if (stat.isDirectory()) {
+    console.log(chalk.yellow(`\n  ⚠️  Bu bir dizin, dosya değil: ${resolved.path}\n`));
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(resolved.path, 'utf8');
+  console.log(chalk.gray(`\n  📄 ${resolved.path}\n`));
+  console.log(content);
+  if (!content.endsWith('\n')) console.log();
+}
+
+function lsPath(uri) {
+  const ncPath = normalizeNcPath(uri || 'nc://w');
+  if (!ncPath) {
+    console.log(chalk.red('\n  ❌ Path gerekli\n'));
+    process.exit(1);
+  }
+
+  const resolved = resolveNcPath(ncPath);
+  if (!resolved) {
+    console.log(chalk.red(`\n  ❌ Çözümlenemedi: ${ncPath}\n`));
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(resolved.path)) {
+    console.log(chalk.red(`\n  ❌ Dizin bulunamadı: ${resolved.path}\n`));
+    process.exit(1);
+  }
+
+  const stat = fs.statSync(resolved.path);
+  if (!stat.isDirectory()) {
+    console.log(chalk.yellow(`\n  ⚠️  Bu bir dosya: ${resolved.path}\n`));
+    process.exit(1);
+  }
+
+  const items = fs.readdirSync(resolved.path);
+  console.log(chalk.cyan(`\n  📂 ${resolved.path}\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  for (const item of items) {
+    const fullPath = path.join(resolved.path, item);
+    const isDir = fs.statSync(fullPath).isDirectory();
+    console.log(`  ${isDir ? chalk.blue('📁') : chalk.gray('📄')} ${isDir ? chalk.cyan(item + '/') : chalk.white(item)}`);
+  }
+
+  console.log();
+}
+
+module.exports = ocPath;

package/src/commands/onboard.js

@@ -0,0 +1,70 @@
+const chalk = require('chalk');
+const readline = require('readline');
+
+function rlQuestion(query) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question(query, answer => { rl.close(); resolve(answer.trim()); });
+  });
+}
+
+async function onboard(args) {
+  console.log(chalk.cyan('\n  🚀 NatureCo Onboarding\n'));
+  console.log(chalk.gray('  Welcome! Let\'s get you set up step by step.\n'));
+
+  const { getConfig, saveConfig } = require('../utils/config');
+  const config = getConfig();
+
+  const start = await rlQuestion('  Begin onboarding? [Y/n]: ');
+  if (start.toLowerCase() === 'n') {
+    console.log(chalk.gray('\n  Skipped. You can always run: natureco onboard\n'));
+    return;
+  }
+
+  // Step 1: Provider
+  console.log(chalk.cyan('\n  Step 1: AI Provider\n'));
+  const provider = await rlQuestion(`  Provider (${config.provider || 'openai'}): `);
+  const model = await rlQuestion(`  Model (${config.model || 'gpt-4o'}): `);
+  config.provider = provider || config.provider || 'openai';
+  config.model = model || config.model || 'gpt-4o';
+  saveConfig(config);
+  console.log(chalk.green(`  ✅ ${config.provider}/${config.model}`));
+
+  // Step 2: API Key
+  if (!config.openaiApiKey && !config.anthropicApiKey) {
+    console.log(chalk.cyan('\n  Step 2: API Key\n'));
+    const apiKey = await rlQuestion(`  Enter your ${config.provider} API key: `);
+    if (apiKey) {
+      config[`${config.provider}ApiKey`] = apiKey;
+      saveConfig(config);
+      console.log(chalk.green('  ✅ API Key saved'));
+    }
+  }
+
+  // Step 3: Gateway
+  console.log(chalk.cyan('\n  Step 3: Gateway\n'));
+  const gUrl = await rlQuestion(`  Gateway URL (${config.gatewayUrl || 'ws://localhost:3848'}): `);
+  const gPort = await rlQuestion(`  Port (${config.gatewayPort || 3848}): `);
+  config.gatewayUrl = gUrl || config.gatewayUrl || 'ws://localhost:3848';
+  config.gatewayPort = parseInt(gPort) || config.gatewayPort || 3848;
+  saveConfig(config);
+  console.log(chalk.green('  ✅ Gateway configured'));
+
+  // Step 4: Workspace
+  console.log(chalk.cyan('\n  Step 4: Workspace\n'));
+  const wsPath = await rlQuestion(`  Workspace path (${process.cwd()}): `);
+  if (wsPath) {
+    config.workspacePath = wsPath;
+    saveConfig(config);
+  }
+  console.log(chalk.green('  ✅ Workspace set'));
+
+  console.log(chalk.green('\n  🎉 Onboarding complete!\n'));
+  console.log(chalk.gray('  Next steps:'));
+  console.log(chalk.cyan('    natureco chat') + chalk.gray('          Start chatting'));
+  console.log(chalk.cyan('    natureco channels add') + chalk.gray('  Connect messaging channels'));
+  console.log(chalk.cyan('    natureco doctor') + chalk.gray('        Health check'));
+  console.log(chalk.cyan('    natureco configure') + chalk.gray('    More settings\n'));
+}
+
+module.exports = onboard;

package/src/commands/open-prose.js

@@ -0,0 +1,67 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+
+function openProse(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'list') return listBundles();
+  if (action === 'info') return showInfo();
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco open-prose [list|info]\n'));
+  process.exit(1);
+}
+
+function listBundles() {
+  const skillsDir = path.join(__dirname, '..', '..', 'skills');
+  console.log(chalk.cyan('\n  📦 OpenProse Skills Bundles\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  let bundles = [];
+  if (fs.existsSync(skillsDir)) {
+    try {
+      bundles = fs.readdirSync(skillsDir).filter(f => f.endsWith('.md'));
+    } catch {}
+  }
+
+  bundles = bundles.length > 0 ? bundles : [
+    'writing-style.md',
+    'code-review.md',
+    'documentation.md',
+    'prompt-engineering.md'
+  ];
+
+  for (const bundle of bundles) {
+    console.log(`  ${chalk.cyan('●')} ${chalk.white(bundle.replace('.md', ''))}`);
+  }
+
+  if (bundles.length === 0) {
+    console.log(chalk.gray('  Yüklü bundle bulunamadı.\n'));
+  }
+
+  console.log(chalk.gray('\n  OpenProse, NatureCo\'nun prose skills paketidir.\n'));
+  console.log(chalk.gray('  Skills yüklemek için:'));
+  console.log(chalk.cyan('    natureco skills install <name>\n'));
+}
+
+function showInfo() {
+  console.log(chalk.cyan('\n  📖 OpenProse\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(chalk.gray('  OpenProse — Prose skills bundle for NatureCo CLI.'));
+  console.log(chalk.gray('  Provides writing, review, documentation, and prompt'));
+  console.log(chalk.gray('  engineering skill definitions.'));
+  console.log();
+  console.log(chalk.gray('  Version: 1.0.0'));
+  console.log(chalk.gray('  ID: open-prose'));
+  console.log(chalk.gray('  Type: skills-bundle'));
+  console.log();
+  console.log(chalk.gray('  Included skills:'));
+  console.log(chalk.cyan('    writing-style') + chalk.gray('    Writing style guide'));
+  console.log(chalk.cyan('    code-review') + chalk.gray('     Code review guidelines'));
+  console.log(chalk.cyan('    documentation') + chalk.gray('  Documentation best practices'));
+  console.log(chalk.cyan('    prompt-engineering') + chalk.gray('  Prompt engineering techniques'));
+  console.log();
+}
+
+module.exports = openProse;

package/src/commands/policy.js

@@ -0,0 +1,176 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { getConfig, saveConfig } = require('../utils/config');
+
+function policy(args) {
+  const [action, ...params] = (args || []);
+
+  if (!action || action === 'check') return checkPolicy();
+  if (action === 'set') return setPolicy(params[0], params.slice(1).join(' '));
+  if (action === 'list') return listPolicies();
+  if (action === 'remove') return removePolicy(params[0]);
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco policy [check|set|list|remove]\n'));
+  process.exit(1);
+}
+
+const POLICY_CHECKS = [
+  {
+    id: 'node-version',
+    name: 'Node.js Versiyonu',
+    check: () => {
+      const v = process.version.slice(1).split('.')[0];
+      return parseInt(v) >= 18
+        ? { status: 'pass', message: `Node.js ${process.version}` }
+        : { status: 'fail', message: `Node.js ${process.version} (18+ gerekli)`, fix: 'Node.js güncelleyin' };
+    }
+  },
+  {
+    id: 'config-exists',
+    name: 'Config Dosyası',
+    check: () => {
+      const configFile = path.join(os.homedir(), '.natureco', 'config.json');
+      if (!fs.existsSync(configFile)) {
+        return { status: 'fail', message: 'config.json bulunamadı', fix: 'natureco setup çalıştırın' };
+      }
+      try {
+        JSON.parse(fs.readFileSync(configFile, 'utf-8'));
+        return { status: 'pass', message: 'Config geçerli JSON' };
+      } catch {
+        return { status: 'fail', message: 'Config bozuk JSON', fix: '~/.natureco/config.json düzeltin' };
+      }
+    }
+  },
+  {
+    id: 'api-key',
+    name: 'API Key',
+    check: () => {
+      const config = getConfig();
+      if (config.providerApiKey || config.apiKey || process.env.GROQ_API_KEY) {
+        return { status: 'pass', message: 'API key mevcut' };
+      }
+      return { status: 'warn', message: 'API key eksik', fix: 'natureco login veya GROQ_API_KEY env' };
+    }
+  },
+  {
+    id: 'provider-url',
+    name: 'Provider URL',
+    check: () => {
+      const config = getConfig();
+      if (config.providerUrl) {
+        return { status: 'pass', message: config.providerUrl };
+      }
+      return { status: 'warn', message: 'Provider ayarlanmamış', fix: 'natureco setup' };
+    }
+  },
+  {
+    id: 'git-config',
+    name: 'Git Yapılandırması',
+    check: () => {
+      try {
+        const { execSync } = require('child_process');
+        const name = execSync('git config user.name', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        const email = execSync('git config user.email', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        if (name && email) return { status: 'pass', message: `${name} <${email}>` };
+        return { status: 'warn', message: 'Git user.name/email eksik', fix: 'git config --global user.name "Adınız"' };
+      } catch {
+        return { status: 'warn', message: 'Git repo değil', fix: 'git init' };
+      }
+    }
+  },
+  {
+    id: 'disk-space',
+    name: 'Disk Alanı',
+    check: () => {
+      try {
+        const drive = path.parse(os.homedir()).root.replace(':', '');
+        const { execSync } = require('child_process');
+        const output = execSync(`powershell -Command "Get-PSDrive -Name ${drive} | Select-Object -ExpandProperty Free"`, { encoding: 'utf-8' }).trim();
+        const free = parseInt(output);
+        if (isNaN(free)) return { status: 'pass', message: 'Kontrol edilemedi' };
+        const freeGB = free / 1e9;
+        if (freeGB < 0.5) return { status: 'fail', message: `Sadece ${freeGB.toFixed(1)}GB boş`, fix: 'Disk temizliği yapın' };
+        return { status: 'pass', message: `${freeGB.toFixed(1)}GB boş alan` };
+      } catch {
+        return { status: 'pass', message: 'Kontrol edilemedi' };
+      }
+    }
+  }
+];
+
+function checkPolicy() {
+  console.log(chalk.cyan.bold('\n  Workspace Uyumluluk Politikası\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  let passed = 0;
+  let failed = 0;
+  let warnings = 0;
+
+  for (const check of POLICY_CHECKS) {
+    const result = check.check();
+    if (result.status === 'pass') {
+      console.log(`  ${chalk.green('✓')} ${check.name}: ${chalk.white(result.message)}`);
+      passed++;
+    } else if (result.status === 'fail') {
+      console.log(`  ${chalk.red('✗')} ${check.name}: ${chalk.white(result.message)}`);
+      console.log(chalk.gray(`    Düzeltme: ${result.fix}`));
+      failed++;
+    } else {
+      console.log(`  ${chalk.yellow('⚠')} ${check.name}: ${chalk.white(result.message)}`);
+      if (result.fix) console.log(chalk.gray(`    Öneri: ${result.fix}`));
+      warnings++;
+    }
+  }
+
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(chalk.gray(`  Geçti: ${passed} | Uyarı: ${warnings} | Hata: ${failed}\n`));
+}
+
+function setPolicy(key, value) {
+  if (!key) {
+    console.log(chalk.red('\n  ❌ Politika adı gerekli\n'));
+    return;
+  }
+  const config = getConfig();
+  if (!config.policies) config.policies = {};
+  config.policies[key] = value;
+  saveConfig(config);
+  console.log(chalk.green(`\n  ✓ Politika ayarlandı: ${key} = ${value}\n`));
+}
+
+function listPolicies() {
+  const config = getConfig();
+  const policies = config.policies || {};
+
+  if (Object.keys(policies).length === 0) {
+    console.log(chalk.gray('\n  Tanımlı politika yok.\n'));
+    return;
+  }
+
+  console.log(chalk.cyan.bold('\n  Tanımlı Politikalar\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  for (const [key, value] of Object.entries(policies)) {
+    console.log(`  ${chalk.white(key)}: ${chalk.cyan(value)}`);
+  }
+  console.log('');
+}
+
+function removePolicy(key) {
+  if (!key) {
+    console.log(chalk.red('\n  ❌ Politika adı gerekli\n'));
+    return;
+  }
+  const config = getConfig();
+  if (config.policies?.[key]) {
+    delete config.policies[key];
+    saveConfig(config);
+    console.log(chalk.green(`\n  ✓ Politika silindi: ${key}\n`));
+  } else {
+    console.log(chalk.yellow(`\n  ⚠ Politika bulunamadı: ${key}\n`));
+  }
+}
+
+module.exports = policy;

package/src/commands/proxy.js

@@ -0,0 +1,155 @@
+const chalk = require('chalk');
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+
+let proxyInstance = null;
+let captured = [];
+let forwardUrl = null;
+
+function proxy(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'status') return statusProxy();
+  if (action === 'start') return startProxy(params);
+  if (action === 'stop') return stopProxy();
+  if (action === 'capture') return showCapture();
+  if (action === 'clear') return clearCapture();
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco proxy [status|start|stop|capture|clear]\n'));
+  process.exit(1);
+}
+
+function statusProxy() {
+  console.log(chalk.cyan('\n  🔍 Debug Proxy\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Status:')}  ${proxyInstance ? chalk.green('Running') : chalk.red('Stopped')}`);
+  if (proxyInstance) {
+    console.log(`  ${chalk.white('Port:')}    ${proxyInstance.port}`);
+    console.log(`  ${chalk.white('Forward:')} ${forwardUrl ? chalk.cyan(forwardUrl) : chalk.gray('(none)')}`);
+    console.log(`  ${chalk.white('Captured:')} ${captured.length} request(s)`);
+  }
+  console.log(chalk.gray('\n  Examples:'));
+  console.log(chalk.gray('  ') + chalk.cyan('natureco proxy start'));
+  console.log(chalk.gray('  ') + chalk.cyan('natureco proxy start 9090'));
+  console.log(chalk.gray('  ') + chalk.cyan('natureco proxy start 8080 --forward http://localhost:3000'));
+  console.log(chalk.gray('  ') + chalk.cyan('natureco proxy capture'));
+  console.log(chalk.gray('  ') + chalk.cyan('natureco proxy clear'));
+  console.log(chalk.gray('  ') + chalk.cyan('natureco proxy stop'));
+  console.log();
+}
+
+function startProxy(params) {
+  if (proxyInstance) {
+    console.log(chalk.yellow('\n  ⚠️  Proxy already running\n'));
+    return;
+  }
+
+  const port = parseInt(params[0], 10) || 8080;
+  const fwdIdx = params.indexOf('--forward');
+  if (fwdIdx !== -1 && params[fwdIdx + 1]) {
+    forwardUrl = params[fwdIdx + 1];
+  }
+
+  captured = [];
+
+  const server = http.createServer((req, res) => {
+    const chunks = [];
+    req.on('data', chunk => chunks.push(chunk));
+    req.on('end', () => {
+      const body = Buffer.concat(chunks).toString();
+      const entry = {
+        id: captured.length + 1,
+        timestamp: new Date().toISOString(),
+        method: req.method,
+        url: req.url,
+        headers: req.headers,
+        body: body ? body.substring(0, 2000) : null
+      };
+      captured.push(entry);
+      if (captured.length > 200) captured.shift();
+
+      console.log(chalk.gray(`  [${entry.id}] ${chalk.cyan(req.method)} ${req.url}`));
+
+      if (forwardUrl) {
+        try {
+          const target = new URL(req.url, forwardUrl);
+          const proxyReq = http.request({
+            hostname: target.hostname,
+            port: target.port || 80,
+            path: target.pathname + target.search,
+            method: req.method,
+            headers: { ...req.headers, host: target.host }
+          }, proxyRes => {
+            let proxyBody = '';
+            proxyRes.on('data', c => proxyBody += c);
+            proxyRes.on('end', () => {
+              res.writeHead(proxyRes.statusCode, proxyRes.headers);
+              res.end(proxyBody);
+            });
+          });
+          proxyReq.on('error', () => {
+            res.writeHead(502);
+            res.end('Bad Gateway');
+          });
+          if (body) proxyReq.write(body);
+          proxyReq.end();
+        } catch {
+          res.writeHead(502);
+          res.end('Bad Gateway');
+        }
+      } else {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true, id: entry.id, captured: captured.length }));
+      }
+    });
+  });
+
+  proxyInstance = server;
+  proxyInstance.port = port;
+  server.listen(port, () => {
+    console.log(chalk.green(`\n  🔍 Debug proxy on http://localhost:${port}\n`));
+    if (forwardUrl) console.log(chalk.gray(`  Forwarding to: ${forwardUrl}\n`));
+    console.log(chalk.gray('  Captured requests shown below. Press Ctrl+C to stop.\n'));
+  });
+}
+
+function stopProxy() {
+  if (!proxyInstance) {
+    console.log(chalk.yellow('\n  ⚠️  Proxy not running\n'));
+    return;
+  }
+  proxyInstance.close(() => {
+    console.log(chalk.gray('\n  🛑 Proxy stopped\n'));
+    proxyInstance = null;
+    forwardUrl = null;
+  });
+}
+
+function showCapture() {
+  if (captured.length === 0) {
+    console.log(chalk.gray('\n  No captured requests.\n'));
+    return;
+  }
+
+  console.log(chalk.cyan(`\n  📋 Captured Requests (${captured.length})\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(64)));
+
+  for (const entry of captured.slice(-20)) {
+    const time = entry.timestamp.slice(11, 19);
+    console.log(`  ${chalk.gray(`[${entry.id}]`)} ${chalk.cyan(entry.method)} ${chalk.white(entry.url)}  ${chalk.gray(time)}`);
+    if (entry.body) {
+      const preview = entry.body.length > 200 ? entry.body.substring(0, 200) + '…' : entry.body;
+      console.log(`    ${chalk.gray(preview)}`);
+    }
+  }
+  console.log();
+}
+
+function clearCapture() {
+  captured = [];
+  console.log(chalk.gray('\n  🗑️  Captured requests cleared\n'));
+}
+
+module.exports = proxy;