@xelth/eck-snapshot 2.2.0 → 4.0.0

package/src/services/claudeCliService.test.js

@@ -0,0 +1,267 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { askClaude } from './claudeCliService.js';
+
+// Mock execa
+vi.mock('execa', () => ({
+  execa: vi.fn()
+}));
+
+// Mock p-retry to control retry behavior in tests
+vi.mock('p-retry', () => ({
+  default: async (fn, options) => {
+    // For tests, we'll execute the function directly without retries
+    return await fn();
+  }
+}));
+
+describe('claudeCliService', () => {
+  let mockExeca;
+
+  beforeEach(async () => {
+    const { execa } = await import('execa');
+    mockExeca = execa;
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('askClaude', () => {
+    it('should successfully execute gemini-cli claude command', async () => {
+      const mockResponse = {
+        stdout: '{"result": "test response", "success": true}',
+        stderr: '',
+        exitCode: 0
+      };
+
+      mockExeca.mockResolvedValue(mockResponse);
+
+      const result = await askClaude('test prompt');
+
+      expect(mockExeca).toHaveBeenCalledWith('gemini-cli', ['claude', 'test prompt'], {
+        timeout: 120000
+      });
+      expect(result).toEqual({
+        stdout: mockResponse.stdout,
+        stderr: mockResponse.stderr,
+        success: true,
+        mcp_feedback: null
+      });
+    });
+
+    it('should handle non-transient errors without retry', async () => {
+      const mockError = new Error('EACCES: permission denied');
+      mockError.code = 'EACCES';
+      mockError.stdout = '';
+      mockError.stderr = 'permission denied';
+
+      mockExeca.mockRejectedValue(mockError);
+
+      const result = await askClaude('test prompt');
+
+      expect(result).toEqual({
+        stdout: '',
+        stderr: 'permission denied',
+        success: false,
+        error: 'EACCES: permission denied'
+      });
+    });
+
+    it('should identify transient network errors', async () => {
+      const mockError = new Error('Connection timeout');
+      mockError.stdout = '';
+      mockError.stderr = 'network timeout occurred';
+
+      const { isTransientError } = await import('./claudeCliService.js');
+
+      expect(isTransientError(mockError)).toBe(true);
+    });
+
+
+    it('should handle JSON parsing in gemini-cli response', async () => {
+      const complexJsonResponse = {
+        stdout: JSON.stringify({
+          type: 'result',
+          data: {
+            analysis: 'test analysis',
+            metrics: { tokens: 100, cost: 0.05 }
+          },
+          timestamp: new Date().toISOString()
+        }),
+        stderr: '',
+        exitCode: 0
+      };
+
+      mockExeca.mockResolvedValue(complexJsonResponse);
+
+      const result = await askClaude('analyze this code');
+
+      expect(result.success).toBe(true);
+      expect(result.stdout).toContain('test analysis');
+      expect(result.stdout).toContain('tokens');
+    });
+
+    it('should handle empty responses gracefully', async () => {
+      const mockResponse = {
+        stdout: '',
+        stderr: '',
+        exitCode: 0
+      };
+
+      mockExeca.mockResolvedValue(mockResponse);
+
+      const result = await askClaude('test prompt');
+
+      expect(result).toEqual({
+        stdout: '',
+        stderr: '',
+        success: true,
+        mcp_feedback: null
+      });
+    });
+
+    it('should handle stderr warnings without failing', async () => {
+      const mockResponse = {
+        stdout: '{"result": "success"}',
+        stderr: 'Warning: deprecated feature used',
+        exitCode: 0
+      };
+
+      mockExeca.mockResolvedValue(mockResponse);
+
+      const result = await askClaude('test prompt');
+
+      expect(result.success).toBe(true);
+      expect(result.stderr).toContain('deprecated feature');
+    });
+
+    it('should respect timeout configuration', async () => {
+      mockExeca.mockResolvedValue({
+        stdout: 'response',
+        stderr: '',
+        exitCode: 0
+      });
+
+      await askClaude('test prompt');
+
+      expect(mockExeca).toHaveBeenCalledWith(
+        'gemini-cli',
+        ['claude', 'test prompt'],
+        { timeout: 120000 }
+      );
+    });
+
+    it('should parse mcp_feedback from JSON prompt', async () => {
+      const mockResponse = {
+        stdout: 'success',
+        stderr: '',
+        exitCode: 0
+      };
+
+      mockExeca.mockResolvedValue(mockResponse);
+
+      const promptWithFeedback = JSON.stringify({
+        payload: {
+          post_execution_steps: {
+            mcp_feedback: {
+              success: true,
+              errors: [],
+              mcp_version: '1.0'
+            }
+          }
+        }
+      });
+
+      const result = await askClaude(promptWithFeedback);
+
+      expect(result.mcp_feedback).toEqual({
+        success: true,
+        errors: [],
+        mcp_version: '1.0'
+      });
+    });
+
+    it('should log warning when mcp_feedback contains errors', async () => {
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const mockResponse = {
+        stdout: 'success',
+        stderr: '',
+        exitCode: 0
+      };
+
+      mockExeca.mockResolvedValue(mockResponse);
+
+      const promptWithErrors = JSON.stringify({
+        payload: {
+          post_execution_steps: {
+            mcp_feedback: {
+              success: false,
+              errors: ['Error 1', 'Error 2'],
+              mcp_version: '1.0'
+            }
+          }
+        }
+      });
+
+      await askClaude(promptWithErrors);
+
+      expect(consoleSpy).toHaveBeenCalledWith('MCP feedback contains errors:', ['Error 1', 'Error 2']);
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('transient error detection', () => {
+    it('should treat network errors as transient', async () => {
+      const { isTransientError } = await import('./claudeCliService.js');
+
+      const networkErrors = [
+        'network error',
+        'timeout',
+        'connection refused',
+        'ECONNRESET',
+        'ENOTFOUND',
+        'socket hang up'
+      ];
+
+      networkErrors.forEach(errorMsg => {
+        const error = new Error(errorMsg);
+        expect(isTransientError(error)).toBe(true);
+      });
+    });
+
+    it('should treat quota errors as transient', async () => {
+      const { isTransientError } = await import('./claudeCliService.js');
+
+      const quotaErrors = [
+        'quota exceeded',
+        'rate limit',
+        'too many requests',
+        '429',
+        '503'
+      ];
+
+      quotaErrors.forEach(errorMsg => {
+        const error = new Error(errorMsg);
+        expect(isTransientError(error)).toBe(true);
+      });
+    });
+
+    it('should not treat permission errors as transient', async () => {
+      const { isTransientError } = await import('./claudeCliService.js');
+
+      const permanentErrors = [
+        'EACCES: permission denied',
+        'Invalid API key',
+        'Authentication failed'
+      ];
+
+      permanentErrors.forEach(errorMsg => {
+        const error = new Error(errorMsg);
+        expect(isTransientError(error)).toBe(false);
+      });
+    });
+  });
+});

package/src/services/dispatcherService.js

@@ -0,0 +1,33 @@
+import { ask as askGpt } from './gptService.js';
+import { executePrompt as askClaude } from './claudeCliService.js';
+
+/**
+ * Dispatches an analytical task to the most efficient AI model with a fallback.
+ * Priority 1: Codex (GPT) with low reasoning for speed and cost.
+ * Priority 2: Claude as a reliable fallback.
+ * @param {string} prompt The JSON payload or prompt string for the task.
+ * @returns {Promise<object>} The result from the successful AI agent.
+ */
+export async function dispatchAnalysisTask(prompt) {
+  try {
+    console.log('🧠 Dispatcher: Attempting analysis with Codex (low reasoning)...');
+    const gptOptions = {
+      model: 'gpt-5-codex',
+      reasoning: 'low'
+    };
+    // The 'ask' function expects payload as first arg, and options as second.
+    // Since prompt is a string here, we wrap it in an object for consistency if needed,
+    // but for simple prompts it can often be passed directly.
+    const payload = (typeof prompt === 'string' && prompt.startsWith('{')) ? prompt : JSON.stringify({ objective: prompt });
+    return await askGpt(payload, { verbose: false, ...gptOptions });
+  } catch (gptError) {
+    console.warn(`⚠️ Codex (low reasoning) failed: ${gptError.message}`);
+    console.log('🔄 Failing over to Claude for analysis...');
+    try {
+      return await askClaude(prompt);
+    } catch (claudeError) {
+      console.error(`❌ Critical Failure: Both Codex and Claude failed for analysis task.`);
+      throw new Error(`Primary (Codex) Error: ${gptError.message}\nFallback (Claude) Error: ${claudeError.message}`);
+    }
+  }
+}

package/src/services/gptService.js

@@ -0,0 +1,302 @@
+import { execa } from 'execa';
+import fs from 'fs/promises';
+import path from 'path';
+import pRetry from 'p-retry';
+import ora from 'ora';
+import { loadProjectEckManifest } from '../utils/fileUtils.js';
+import { initiateLogin } from './authService.js';
+import which from 'which';
+
+const SYSTEM_PROMPT = 'You are a Coder agent. Apply code changes per JSON spec. Respond only in JSON: {success: bool, changes: array, errors: array, post_steps: object}';
+
+class AuthError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AuthError';
+  }
+}
+
+/**
+ * Checks if the codex CLI tool is available in the system's PATH.
+ * Throws an error if not found.
+ */
+async function ensureCodexCliExists() {
+  try {
+    await which('codex');
+  } catch (error) {
+    throw new Error('The `codex` CLI tool is not installed or not in your PATH. Please install it from https://github.com/openai/codex to use this command.');
+  }
+}
+
+/**
+ * Delegates an apply_code_changes payload to the codex CLI with auto-login.
+ * @param {string|object} payload - JSON string or object payload to forward to the agent.
+ * @param {{ verbose?: boolean, model?: string, reasoning?: string }} [options]
+ * @returns {Promise<object>}
+ */
+export async function ask(payload, options = {}) {
+  const { verbose = false, model = 'gpt-5-codex', reasoning = 'high' } = options;
+  await ensureCodexCliExists();
+
+  const run = async () => {
+    const spinner = verbose ? null : ora('Sending payload to Codex agent...').start();
+    try {
+      const payloadObject = await parsePayload(payload);
+      const manifest = await loadProjectEckManifest(process.cwd());
+      const userPrompt = buildUserPrompt(payloadObject, manifest);
+      const promptInput = `${SYSTEM_PROMPT}\n\n${userPrompt}`;
+
+      const args = [
+        'exec',
+        // Use full-auto mode to prevent interactive prompts from the agent,
+        // as this service is designed for non-interactive delegation.
+        '--full-auto',
+        '--model', model,
+        '-c', `model_reasoning_effort=${reasoning}`
+      ];
+
+      debug(verbose, `Executing: codex ${args.join(' ')} <stdin>`);
+
+      const cliResult = await execa('codex', args, {
+        cwd: process.cwd(),
+        timeout: 300000, // 5-minute timeout
+        input: promptInput // Stream large prompts via stdin to avoid argv limits
+      });
+
+      const output = cliResult?.stdout?.trim();
+      if (!output) {
+        throw new Error('codex CLI returned empty response');
+      }
+
+      const parsed = extractFinalJson(output);
+      if (parsed) {
+        if (parsed.post_steps || parsed.post_execution_steps) {
+          const postSteps = parsed.post_steps || parsed.post_execution_steps;
+          await handlePostExecutionSteps(postSteps, payloadObject);
+          parsed.mcp_feedback = postSteps?.mcp_feedback || null;
+        }
+        spinner?.succeed('Codex agent completed the task.');
+        return parsed;
+      }
+
+      // If parsing fails, surface the raw response text for upstream handling.
+      spinner?.succeed('Codex agent completed the task.');
+      return { success: true, changes: [], errors: [], response_text: output };
+
+    } catch (error) {
+        spinner?.fail('Codex execution failed.');
+        handleCliError(error); // This will throw a specific error type
+    }
+  };
+
+  return pRetry(run, {
+    retries: 1, // Only retry once after a successful login
+    minTimeout: 0,
+    onFailedAttempt: async (error) => {
+      if (error.name === 'AuthError') {
+        await initiateLogin();
+      } else {
+        throw error; // Don't retry for other errors, fail immediately
+      }
+    }
+  });
+}
+
+
+async function parsePayload(payload) {
+  if (typeof payload === 'string') {
+    try {
+      return JSON.parse(payload);
+    } catch (error) {
+      throw new Error(`Failed to parse payload JSON: ${error.message}`);
+    }
+  }
+  if (typeof payload === 'object' && payload !== null) {
+    return payload;
+  }
+  throw new Error('Invalid payload type. Expected JSON string or object.');
+}
+
+function buildUserPrompt(payloadObject, manifest) {
+  const payloadString = JSON.stringify(payloadObject);
+  if (!manifest) {
+    return payloadString;
+  }
+
+  const sections = [];
+  if (manifest.context) {
+    sections.push('## .eck Context\n' + manifest.context);
+  }
+  if (manifest.operations) {
+    sections.push('## .eck Operations\n' + manifest.operations);
+  }
+  if (manifest.journal) {
+    sections.push('## .eck Journal\n' + manifest.journal);
+  }
+  if (manifest.environment && Object.keys(manifest.environment).length > 0) {
+    sections.push('## .eck Environment\n' + JSON.stringify(manifest.environment, null, 2));
+  }
+
+  if (sections.length === 0) {
+    return payloadString;
+  }
+
+  return `${payloadString}\n\n# Project Context\n${sections.join('\n\n')}`;
+}
+
+function debug(verbose, message) {
+  if (verbose) {
+    console.log(`[ask-gpt] ${message}`);
+  }
+}
+
+function extractFinalJson(text) {
+  const trimmed = text?.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(trimmed);
+  } catch (error) {
+    // Continue with fallback parsing when logs precede the JSON payload.
+  }
+
+  const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fencedMatch && fencedMatch[1]) {
+    const fencedContent = fencedMatch[1].trim();
+    try {
+      return JSON.parse(fencedContent);
+    } catch (error) {
+      // Ignore and fall through to final brace search.
+    }
+  }
+
+  const lastBraceIndex = trimmed.lastIndexOf('{');
+  if (lastBraceIndex === -1) {
+    return null;
+  }
+
+  const jsonCandidate = trimmed.slice(lastBraceIndex);
+  try {
+    return JSON.parse(jsonCandidate);
+  } catch (error) {
+    return null;
+  }
+}
+
+function handleCliError(error) {
+  const combined = `${error?.message || ''} ${error?.stderr || ''} ${error?.stdout || ''}`.toLowerCase();
+  // Check for text that `codex` outputs when auth is missing.
+  if (combined.includes('authentication is required') || combined.includes('please run `codex login`')) {
+    const authError = new Error('Codex authentication is required. Attempting to log in.');
+    authError.name = 'AuthError';
+    throw authError;
+  }
+
+  throw new Error(`codex CLI failed: ${error.stderr || error.message}`);
+}
+
+async function handlePostExecutionSteps(postSteps, payloadObject) {
+  if (!postSteps || typeof postSteps !== 'object') {
+    return;
+  }
+
+  if (postSteps.journal_entry) {
+    await applyJournalEntry(postSteps.journal_entry, payloadObject);
+  }
+
+  if (postSteps.mcp_feedback) {
+    logMcpFeedback(postSteps.mcp_feedback);
+  }
+}
+
+async function applyJournalEntry(entry, payloadObject) {
+  const journalEntry = normalizeJournalEntry(entry);
+  const journalPath = path.join(process.cwd(), '.eck', 'JOURNAL.md');
+
+  await fs.mkdir(path.dirname(journalPath), { recursive: true });
+
+  let existing = '';
+  try {
+    existing = await fs.readFile(journalPath, 'utf-8');
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw new Error(`Failed to read JOURNAL.md: ${error.message}`);
+    }
+  }
+
+  const taskId = payloadObject?.task_id || payloadObject?.payload?.task_id || journalEntry.task_id || 'ask-gpt';
+  const isoDate = new Date().toISOString();
+
+  const frontmatter = [
+    '---',
+    `task_id: ${taskId}`,
+    `date: ${isoDate}`,
+    `type: ${journalEntry.type}`,
+    `scope: ${journalEntry.scope}`,
+    '---',
+    ''
+  ].join('\n');
+
+  const summary = journalEntry.summary ? `## ${journalEntry.summary}\n` : '';
+  const details = journalEntry.details ? `${journalEntry.details}\n` : '';
+
+  const entryBlock = `${frontmatter}${summary ? `${summary}\n` : ''}${details}\n`;
+
+  const existingTrimmed = existing ? existing.replace(/^\n+/, '') : '';
+  const newContent = `${entryBlock}${existingTrimmed}`.replace(/\n{3,}/g, '\n\n');
+
+  await fs.writeFile(journalPath, newContent.trimEnd() + '\n');
+
+  await stageJournal(journalPath);
+  await commitJournal(journalEntry);
+}
+
+function normalizeJournalEntry(entry) {
+  return {
+    type: entry.type || 'chore',
+    scope: entry.scope || 'journal',
+    summary: entry.summary || 'Update journal entry',
+    details: entry.details || ''
+  };
+}
+
+async function stageJournal(journalPath) {
+  const relativePath = path.relative(process.cwd(), journalPath);
+  try {
+    await execa('git', ['add', relativePath], { cwd: process.cwd() });
+  } catch (error) {
+    throw new Error(`Failed to stage journal entry: ${error.message}`);
+  }
+}
+
+async function commitJournal(entry) {
+  const scopePart = entry.scope ? `(${entry.scope})` : '';
+  const summary = (entry.summary || 'Update journal entry').replace(/\s+/g, ' ').trim();
+  const commitMessage = `${entry.type}${scopePart}: ${summary}`;
+
+  try {
+    await execa('git', ['commit', '-m', commitMessage], { cwd: process.cwd() });
+  } catch (error) {
+    const text = `${error?.stderr || ''} ${error?.stdout || ''}`.toLowerCase();
+    if (text.includes('nothing to commit')) {
+      console.warn('Journal entry already committed or no changes to commit.');
+      return;
+    }
+    throw new Error(`Failed to commit journal entry: ${error.message}`);
+  }
+}
+
+function logMcpFeedback(feedback) {
+  if (!feedback) {
+    return;
+  }
+
+  const errors = Array.isArray(feedback.errors) ? feedback.errors : [];
+  if (!feedback.success || errors.length > 0) {
+    console.warn('MCP feedback indicates issues:', errors.length > 0 ? errors : feedback);
+  } else {
+    console.log('MCP feedback:', feedback);
+  }
+}