myshell-tools 1.0.0

package/src/providers/claude.mjs

@@ -0,0 +1,236 @@
+/**
+ * claude.mjs — Claude CLI subprocess wrapper with robust error handling
+ */
+
+import { spawnSync } from 'child_process';
+import {
+  executeWithRecovery,
+  parseCliOutput,
+  createFriendlyErrorMessage,
+  CliError,
+  defaultRetryCallback
+} from './errors.mjs';
+
+/**
+ * Execute a Claude command with the specified model and prompt
+ */
+export async function executeClaude(claudeBin, model, prompt, options = {}) {
+  const startTime = Date.now();
+
+  const args = [
+    '-p',
+    '--model', model,
+    '--output-format', 'stream-json',
+    '--verbose'
+  ];
+
+  // Add the prompt as the final argument
+  args.push(prompt);
+
+  let proc;
+  try {
+    proc = await executeWithRecovery(claudeBin, args, {
+      provider: 'claude',
+      timeoutMs: options.timeoutMs || 120000,
+      cwd: options.cwd || process.cwd(),
+      onRetry: options.onRetry || defaultRetryCallback
+    });
+  } catch (error) {
+    // Return error result in expected format
+    return {
+      success: false,
+      output: '',
+      confidence: null,
+      escalate: false,
+      reasoning: 'CLI execution failed',
+      durationMs: Date.now() - startTime,
+      model,
+      provider: 'claude',
+      exitCode: error.details?.exitCode || -1,
+      stderr: error.details?.stderr || error.message,
+      error: createFriendlyErrorMessage(error, 'claude')
+    };
+  }
+
+  const durationMs = Date.now() - startTime;
+
+  // Parse streaming JSON output
+  let output = '';
+  let confidence = null;
+  let escalate = false;
+  let reasoning = '';
+
+  try {
+    if (proc.stdout) {
+      // Claude streams JSON objects, one per line
+      const lines = proc.stdout.trim().split('\n').filter(l => l.trim());
+
+      for (const line of lines) {
+        try {
+          const data = JSON.parse(line);
+
+          // Look for assistant messages with content
+          if (data.type === 'assistant' && data.message && data.message.content) {
+            for (const content of data.message.content) {
+              if (content.type === 'text' && content.text) {
+                output += content.text;
+              }
+            }
+          }
+        } catch {
+          // If not JSON, treat as plain text (fallback)
+          output += line + '\n';
+        }
+      }
+    }
+
+    // Try to extract confidence and escalation info from output
+    const confidenceMatch = output.match(/"confidence":\s*([0-9.]+)/);
+    const escalateMatch = output.match(/"escalate":\s*(true|false)/);
+    const reasonMatch = output.match(/"reason":\s*"([^"]+)"/);
+
+    if (confidenceMatch) confidence = parseFloat(confidenceMatch[1]);
+    if (escalateMatch) escalate = escalateMatch[1] === 'true';
+    if (reasonMatch) reasoning = reasonMatch[1];
+
+  } catch (err) {
+    // Fallback to plain text if JSON parsing fails
+    output = proc.stdout || '';
+  }
+
+  // Parse CLI output for better error handling
+  const parsedOutput = parseCliOutput(proc.stdout, proc.stderr, proc.status);
+
+  return {
+    success: parsedOutput.success,
+    output: output.trim(),
+    confidence,
+    escalate,
+    reasoning,
+    durationMs,
+    model,
+    provider: 'claude',
+    exitCode: proc.status,
+    stderr: proc.stderr || '',
+    error: parsedOutput.success ? null : createFriendlyErrorMessage({
+      message: parsedOutput.error,
+      details: {
+        errorType: parsedOutput.errorType,
+        suggestions: parsedOutput.suggestions,
+        isRecoverable: parsedOutput.isRecoverable
+      }
+    }, 'claude')
+  };
+}
+
+/**
+ * Build a hierarchical prompt for Claude based on tier and context
+ */
+export function buildClaudePrompt(tier, task, context = {}) {
+  let prompt = '';
+
+  // Enhanced prompts with manager feedback support
+  switch (tier) {
+    case 'worker':
+      prompt = `You are a WORKER in an AI organization hierarchy. Handle this specific, simple task efficiently:
+
+TASK: ${task}
+
+You are the cheapest, fastest model in the org chart. Focus on:
+- File lookups, grep operations, simple reads
+- Quick information gathering
+- Basic operations that don't require complex reasoning
+
+Work efficiently and honestly. If the task is more complex than you can handle confidently, be honest about it.
+
+End your response with: {"confidence": 0.0-1.0, "escalate": true|false, "reason": "brief explanation", "needs_review": true|false}`;
+      break;
+
+    case 'ic':
+      // Check if this is a retry with manager feedback
+      if (context.managerNotes) {
+        prompt = `You are an IC (Individual Contributor) in an AI organization. You handle most of the implementation work:
+
+TASK: ${task}
+
+MANAGER FEEDBACK (from previous attempt):
+═══════════════════════════════════════
+${context.managerNotes}
+═══════════════════════════════════════
+
+Your manager has reviewed your previous work and wants you to address the above issues.
+Focus on fixing exactly what they pointed out.
+
+${context.attempt ? `This is attempt #${context.attempt}. Apply the manager's feedback carefully.` : ''}
+
+You are the primary workhorse - most tasks should be completed at your level. Focus on:
+- Code implementation and editing
+- Refactoring and improvements
+- Running tests and debugging
+- Git operations and file management
+
+If you encounter something that needs architectural decisions, security review, or complex debugging, escalate to your manager.
+
+End your response with: {"confidence": 0.0-1.0, "escalate": true|false, "reason": "brief explanation", "needs_review": true|false}`;
+      } else {
+        prompt = `You are an IC (Individual Contributor) in an AI organization. You handle most of the implementation work:
+
+TASK: ${task}
+
+You are the primary workhorse - most tasks should be completed at your level. Focus on:
+- Code implementation and editing
+- Refactoring and improvements
+- Running tests and debugging
+- Git operations and file management
+
+If you encounter something that needs architectural decisions, security review, or complex debugging, escalate to your manager.
+
+End your response with: {"confidence": 0.0-1.0, "escalate": true|false, "reason": "brief explanation", "needs_review": true|false}`;
+      }
+      break;
+
+    case 'manager':
+      // Check if this is a manager review operation
+      if (context.operation === 'review') {
+        prompt = task; // task already contains the full review prompt
+      } else {
+        prompt = `You are a MANAGER in an AI organization. Handle high-level decisions and review complex problems:
+
+TASK: ${task}
+
+You handle:
+- Architecture decisions
+- Security reviews
+- Complex debugging that requires deep reasoning
+- Code reviews and quality decisions
+- Escalated issues from ICs
+
+Either solve the problem completely or provide specific guidance for your team to implement.
+
+End your response with: {"confidence": 0.0-1.0, "escalate": false, "reason": "solution approach", "needs_review": false}`;
+      }
+      break;
+
+    default:
+      prompt = `Handle this task: ${task}
+
+End your response with: {"confidence": 0.0-1.0, "escalate": true|false, "reason": "brief explanation", "needs_review": true|false}`;
+  }
+
+  // Add context if available (skip for review operations)
+  if (context.operation !== 'review') {
+    if (context.files && context.files.length > 0) {
+      prompt += `\n\nRelevant files:\n${context.files.map(f => `- ${f}`).join('\n')}`;
+    }
+
+    if (context.constraints && context.constraints.length > 0) {
+      prompt += `\n\nConstraints:\n${context.constraints.map(c => `- ${c}`).join('\n')}`;
+    }
+
+    if (context.previous && tier === 'manager' && !context.managerNotes) {
+      prompt += `\n\nPREVIOUS ATTEMPT (escalated to you):\n${context.previous.output}\n\nConfidence was: ${context.previous.confidence}\nReason for escalation: ${context.previous.reasoning}`;
+    }
+  }
+
+  return prompt;
+}

package/src/providers/codex.mjs

@@ -0,0 +1,255 @@
+/**
+ * codex.mjs — Codex CLI subprocess wrapper with robust error handling
+ * Adapted from archive/dual-brain/hooks/gpt-work-dispatcher.mjs
+ */
+
+import { spawnSync } from 'child_process';
+import {
+  executeWithRecovery,
+  parseCliOutput,
+  createFriendlyErrorMessage,
+  CliError,
+  defaultRetryCallback
+} from './errors.mjs';
+
+/**
+ * Execute a Codex command with the specified model and prompt
+ */
+export async function executeCodex(codexBin, model, prompt, options = {}) {
+  const startTime = Date.now();
+
+  const args = [
+    'exec', '--json', '--ephemeral',
+    '-m', model,
+    '-s', 'danger-full-access',
+    prompt
+  ];
+
+  let proc;
+  try {
+    proc = await executeWithRecovery(codexBin, args, {
+      provider: 'codex',
+      timeoutMs: options.timeoutMs || 120000,
+      cwd: options.cwd || process.cwd(),
+      onRetry: options.onRetry || defaultRetryCallback
+    });
+  } catch (error) {
+    // Return error result in expected format
+    return {
+      success: false,
+      output: '',
+      confidence: null,
+      escalate: false,
+      reasoning: 'CLI execution failed',
+      durationMs: Date.now() - startTime,
+      model,
+      provider: 'codex',
+      usage: null,
+      errors: [error.message],
+      exitCode: error.details?.exitCode || -1,
+      stderr: error.details?.stderr || error.message,
+      error: createFriendlyErrorMessage(error, 'codex')
+    };
+  }
+
+  const durationMs = Date.now() - startTime;
+
+  // Parse JSONL output (each line is a JSON object)
+  let output = '';
+  let confidence = null;
+  let escalate = false;
+  let reasoning = '';
+  let usage = null;
+  const errors = [];
+
+  try {
+    const messages = (proc.stdout || '')
+      .split('\n')
+      .filter(l => l.trim())
+      .map(l => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+
+    // Extract agent messages (the actual AI response)
+    const agentMessages = messages
+      .filter(m => m.type === 'item.completed' && m.item?.type === 'agent_message')
+      .map(m => m.item.text);
+
+    output = agentMessages.join('\n\n');
+
+    // Get usage statistics
+    const turnCompleted = messages.find(m => m.type === 'turn.completed');
+    if (turnCompleted) {
+      usage = turnCompleted.usage;
+    }
+
+    // Collect errors
+    messages
+      .filter(m => m.type === 'error' || m.type === 'turn.failed')
+      .forEach(m => errors.push(m.message || m.error?.message || 'unknown error'));
+
+    // Try to extract confidence and escalation info from the last agent message
+    if (output) {
+      const confidenceMatch = output.match(/"confidence":\s*([0-9.]+)/);
+      const escalateMatch = output.match(/"escalate":\s*(true|false)/);
+      const reasonMatch = output.match(/"reason":\s*"([^"]+)"/);
+
+      if (confidenceMatch) confidence = parseFloat(confidenceMatch[1]);
+      if (escalateMatch) escalate = escalateMatch[1] === 'true';
+      if (reasonMatch) reasoning = reasonMatch[1];
+    }
+
+  } catch (err) {
+    errors.push(`Parse error: ${err.message}`);
+    output = proc.stdout || '';
+  }
+
+  // Parse CLI output for better error handling
+  const parsedOutput = parseCliOutput(proc.stdout, proc.stderr, proc.status);
+
+  return {
+    success: parsedOutput.success && errors.length === 0,
+    output: output.trim(),
+    confidence,
+    escalate,
+    reasoning,
+    durationMs,
+    model,
+    provider: 'codex',
+    usage,
+    errors,
+    exitCode: proc.status,
+    stderr: proc.stderr || '',
+    error: (parsedOutput.success && errors.length === 0) ? null :
+           createFriendlyErrorMessage({
+             message: errors.length > 0 ? errors.join('; ') : parsedOutput.error,
+             details: {
+               errorType: parsedOutput.errorType,
+               suggestions: parsedOutput.suggestions,
+               isRecoverable: parsedOutput.isRecoverable
+             }
+           }, 'codex')
+  };
+}
+
+/**
+ * Build a hierarchical prompt for Codex based on tier and context
+ */
+export function buildCodexPrompt(tier, task, context = {}) {
+  let prompt = '';
+
+  // Enhanced prompts with manager feedback support
+  switch (tier) {
+    case 'worker':
+      prompt = `You are a WORKER in an AI organization hierarchy. Handle this specific, simple task efficiently:
+
+TASK: ${task}
+
+You are the cheapest, fastest model in the org chart. Focus on:
+- File lookups, grep operations, simple reads
+- Quick information gathering
+- Basic operations that don't require complex reasoning
+
+Work efficiently and honestly. If the task is more complex than you can handle confidently, be honest about it.
+
+When complete, output a summary and end with: {"confidence": 0.0-1.0, "escalate": true|false, "reason": "brief explanation", "needs_review": true|false}`;
+      break;
+
+    case 'ic':
+      // Check if this is a retry with manager feedback
+      if (context.managerNotes) {
+        prompt = `You are an IC (Individual Contributor) in an AI organization. You handle most implementation work:
+
+TASK: ${task}
+
+MANAGER FEEDBACK (from previous attempt):
+═══════════════════════════════════════
+${context.managerNotes}
+═══════════════════════════════════════
+
+Your manager has reviewed your previous work and wants you to address the above issues.
+Focus on fixing exactly what they pointed out.
+
+${context.attempt ? `This is attempt #${context.attempt}. Apply the manager's feedback carefully.` : ''}
+
+Own this task completely. Edit files directly. Run tests to verify your changes.
+
+When complete, output:
+1. What you changed (files and behavior)
+2. How you addressed the manager's feedback
+3. Tests run and results (if applicable)
+4. Remaining risks or edge cases
+5. End with: {"confidence": 0.0-1.0, "escalate": true|false, "reason": "brief explanation", "needs_review": true|false}`;
+      } else {
+        prompt = `You are an IC (Individual Contributor) in an AI organization. You handle most implementation work:
+
+TASK: ${task}
+
+You are the primary workhorse - most tasks should be completed at your level. Focus on:
+- Code implementation and editing
+- Refactoring and improvements
+- Running tests and debugging
+- Git operations and file management
+
+Own this task completely. Edit files directly. Run tests to verify your changes.
+
+If you encounter something requiring architectural decisions, security review, or complex debugging, escalate to your manager.
+
+When complete, output:
+1. What you changed (files and behavior)
+2. Tests run and results (if applicable)
+3. Remaining risks or edge cases
+4. End with: {"confidence": 0.0-1.0, "escalate": true|false, "reason": "brief explanation", "needs_review": true|false}`;
+      }
+      break;
+
+    case 'manager':
+      // Check if this is a manager review operation
+      if (context.operation === 'review') {
+        prompt = task; // task already contains the full review prompt
+      } else {
+        prompt = `You are a MANAGER in an AI organization. Handle high-level decisions and review complex problems:
+
+TASK: ${task}
+
+You handle:
+- Architecture decisions
+- Security reviews
+- Complex debugging that requires deep reasoning
+- Code reviews and quality decisions
+- Escalated issues from ICs
+
+Either solve the problem completely or provide specific guidance for your team to implement.
+
+When complete, output your decision/solution and end with: {"confidence": 0.0-1.0, "escalate": false, "reason": "solution approach", "needs_review": false}`;
+      }
+      break;
+
+    default:
+      prompt = `Handle this task: ${task}
+
+End with: {"confidence": 0.0-1.0, "escalate": true|false, "reason": "brief explanation", "needs_review": true|false}`;
+  }
+
+  // Add context if available (skip for review operations)
+  if (context.operation !== 'review') {
+    if (context.files && context.files.length > 0) {
+      prompt += `\n\nRelevant files:\n${context.files.map(f => `- ${f}`).join('\n')}`;
+    }
+
+    if (context.constraints && context.constraints.length > 0) {
+      prompt += `\n\nConstraints:\n${context.constraints.map(c => `- ${c}`).join('\n')}`;
+    }
+
+    if (context.previous && tier === 'manager' && !context.managerNotes) {
+      prompt += `\n\nPREVIOUS ATTEMPT (escalated to you):\nOutput: ${context.previous.output}\nConfidence: ${context.previous.confidence}\nEscalation reason: ${context.previous.reasoning}`;
+    }
+  }
+
+  return prompt;
+}

package/src/providers/detect.mjs

@@ -0,0 +1,185 @@
+/**
+ * detect.mjs — CLI detection and auth status checking for Claude and Codex
+ * Adapted from archive/dual-brain/install.mjs
+ */
+
+import { spawnSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+
+/**
+ * Run a command and capture output safely
+ */
+function run(cmd, args = [], options = {}) {
+  try {
+    return spawnSync(cmd, args, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 10000,
+      ...options
+    });
+  } catch (err) {
+    return { status: -1, stdout: '', stderr: err.message };
+  }
+}
+
+/**
+ * Detect Claude CLI installation and authentication status
+ */
+export function detectClaude() {
+  const result = {
+    installed: false,
+    version: null,
+    authed: false,
+    models: [],
+    bin: 'claude'
+  };
+
+  // Try to get version
+  const ver = run('claude', ['--version']);
+  if (ver.status === 0 && ver.stdout.trim()) {
+    result.installed = true;
+    result.version = ver.stdout.trim().split('\n')[0];
+  }
+
+  // Fallback: check if claude exists in PATH
+  if (!result.installed) {
+    const which = run('which', ['claude']);
+    if (which.status === 0 && which.stdout.trim()) {
+      result.installed = true;
+      result.bin = which.stdout.trim();
+    }
+  }
+
+  // Check authentication via credential files
+  const credPaths = [
+    join(process.env.HOME || '', '.claude', '.credentials.json'),
+    join(process.env.HOME || '', '.claude', 'credentials.json'),
+    resolve(process.cwd(), '.replit-tools', '.claude-persistent', '.credentials.json'),
+  ];
+
+  for (const p of credPaths) {
+    try {
+      const cred = JSON.parse(readFileSync(p, 'utf8'));
+      if (cred.claudeAiOauth || cred.apiKey || cred.oauth_token) {
+        result.authed = true;
+        break;
+      }
+    } catch {}
+  }
+
+  // Fallback: check auth status command
+  if (!result.authed && result.installed) {
+    const auth = run('claude', ['auth', 'status']);
+    const out = ((auth.stdout || '') + (auth.stderr || '')).toLowerCase();
+    if (out.includes('logged in') || out.includes('authenticated') || out.includes('valid')) {
+      result.authed = true;
+    }
+  }
+
+  // If installed and authed, assume standard models are available
+  if (result.installed && result.authed) {
+    result.models = ['opus', 'sonnet', 'haiku'];
+  }
+
+  return result;
+}
+
+/**
+ * Detect Codex CLI installation and authentication status
+ */
+export function detectCodex() {
+  const result = {
+    installed: false,
+    version: null,
+    authed: false,
+    path: null,
+    models: []
+  };
+
+  // Try which first
+  const which = run('which', ['codex']);
+  if (which.status === 0 && which.stdout.trim()) {
+    result.path = which.stdout.trim();
+    result.installed = true;
+  }
+
+  // Try common fallback locations
+  if (!result.installed) {
+    const home = process.env.HOME || '';
+    const fallbacks = [
+      join(home, '.local', 'bin', 'codex'),
+      join(home, 'bin', 'codex'),
+      '/usr/local/bin/codex',
+    ];
+    for (const p of fallbacks) {
+      if (existsSync(p)) {
+        result.path = p;
+        result.installed = true;
+        break;
+      }
+    }
+  }
+
+  if (result.installed && result.path) {
+    // Get version
+    const ver = run(result.path, ['--version']);
+    if (ver.status === 0) {
+      result.version = ver.stdout.trim().split('\n')[0];
+    }
+
+    // Check login status
+    const login = run(result.path, ['login', 'status']);
+    const out = ((login.stdout || '') + (login.stderr || '')).toLowerCase();
+    if (login.status === 0 || out.includes('logged in') || out.includes('authenticated')) {
+      result.authed = true;
+    }
+
+    // If installed and authed, assume standard models
+    if (result.authed) {
+      result.models = ['gpt-5.5', 'gpt-5.4', 'gpt-4.1-mini'];
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Detect all available providers and their capabilities
+ */
+export function detectEnvironment() {
+  const claude = detectClaude();
+  const codex = detectCodex();
+
+  return {
+    claude,
+    codex,
+    hasProviders: (claude.installed && claude.authed) || (codex.installed && codex.authed),
+    workspace: resolve(process.cwd())
+  };
+}
+
+/**
+ * Get available models organized by tier
+ */
+export function getAvailableModels(env) {
+  const models = {
+    worker: [],
+    ic: [],
+    manager: []
+  };
+
+  if (env.claude.installed && env.claude.authed) {
+    models.worker.push({ provider: 'claude', model: 'haiku', bin: env.claude.bin });
+    models.ic.push({ provider: 'claude', model: 'sonnet', bin: env.claude.bin });
+    models.manager.push({ provider: 'claude', model: 'opus', bin: env.claude.bin });
+  }
+
+  if (env.codex.installed && env.codex.authed) {
+    models.worker.push({ provider: 'codex', model: 'gpt-4.1-mini', bin: env.codex.path });
+    models.ic.push({ provider: 'codex', model: 'gpt-5.4', bin: env.codex.path });
+    models.manager.push({ provider: 'codex', model: 'gpt-5.5', bin: env.codex.path });
+  }
+
+  return models;
+}