git-coco 0.27.0 → 0.28.0

package/dist/index.esm.mjs

@@ -46,7 +46,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.27.0";
+const BUILD_VERSION = "0.28.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -226,6 +226,16 @@ class LangChainAuthenticationError extends LangChainError {
         super(message, context);
     }
 }
+/**
+ * Network/connection errors (service unreachable, DNS failures, etc.)
+ */
+class LangChainNetworkError extends LangChainError {
+    constructor(message, endpoint, provider, context) {
+        super(message, { ...context, endpoint, provider });
+        this.endpoint = endpoint;
+        this.provider = provider;
+    }
+}
 
 /**
  * Validates that a required parameter is not null or undefined
@@ -2351,6 +2361,59 @@ class Logger {
     }
 }
 
+/**
+ * Formats a network error with helpful troubleshooting information
+ */
+function formatNetworkError(error, logger) {
+    const endpoint = error.endpoint || 'unknown endpoint';
+    const provider = error.provider || 'LLM service';
+    logger.log('\nFailed to execute command', { color: 'yellow' });
+    logger.log(`\nError: Unable to connect to ${provider}`, { color: 'red' });
+    if (error.endpoint) {
+        logger.log(`       Endpoint: ${endpoint}`, { color: 'red' });
+    }
+    logger.log('\nTroubleshooting:', { color: 'cyan' });
+    // Provider-specific troubleshooting
+    if (provider === 'ollama' || endpoint.includes('11434')) {
+        logger.log('  • Is Ollama running? Try: ollama serve', { color: 'white' });
+        logger.log('  • Check if the endpoint is correct in your config', { color: 'white' });
+        logger.log(`  • Verify Ollama is accessible: curl ${endpoint}/api/version`, { color: 'white' });
+    }
+    else if (provider === 'openai' || endpoint.includes('openai')) {
+        logger.log('  • Check your internet connection', { color: 'white' });
+        logger.log('  • Verify the API endpoint is accessible', { color: 'white' });
+        logger.log('  • If using a custom baseURL, verify it is correct', { color: 'white' });
+    }
+    else if (provider === 'anthropic') {
+        logger.log('  • Check your internet connection', { color: 'white' });
+        logger.log('  • Verify the Anthropic API is accessible', { color: 'white' });
+    }
+    else {
+        logger.log('  • Check your internet connection', { color: 'white' });
+        logger.log('  • Verify the service endpoint is correct', { color: 'white' });
+        logger.log('  • Ensure the LLM service is running and accessible', { color: 'white' });
+    }
+    logger.verbose(`\nOriginal error: ${error.message}`, { color: 'gray' });
+}
+/**
+ * Formats an authentication error with helpful information
+ */
+function formatAuthenticationError(error, logger) {
+    logger.log('\nFailed to execute command', { color: 'yellow' });
+    logger.log('\nError: Authentication failed', { color: 'red' });
+    logger.log('\nTroubleshooting:', { color: 'cyan' });
+    logger.log('  • Verify your API key is correct', { color: 'white' });
+    logger.log('  • Check that your API key has not expired', { color: 'white' });
+    logger.log('  • Ensure the API key is set in your environment or config', { color: 'white' });
+    logger.verbose(`\nOriginal error: ${error.message}`, { color: 'gray' });
+}
+/**
+ * Formats a generic error
+ */
+function formatGenericError(error, logger) {
+    logger.log('\nFailed to execute command', { color: 'yellow' });
+    logger.verbose(`\nError: "${error.message}"`, { color: 'red' });
+}
 function commandExecutor(handler) {
     return async (argv) => {
         const options = loadConfig(argv);
@@ -2359,8 +2422,16 @@ function commandExecutor(handler) {
             await handler(argv, logger);
         }
         catch (error) {
-            logger.log('\nFailed to execute command', { color: 'yellow' });
-            logger.verbose(`\nError: "${error.message}"`, { color: 'red' });
+            // Handle specific error types with helpful messages
+            if (error instanceof LangChainNetworkError) {
+                formatNetworkError(error, logger);
+            }
+            else if (error instanceof LangChainAuthenticationError) {
+                formatAuthenticationError(error, logger);
+            }
+            else {
+                formatGenericError(error, logger);
+            }
             logger.log('\nThanks for using coco, make it a great day! 👋🤖', { color: 'blue' });
             process.exit(0);
         }
@@ -6252,10 +6323,50 @@ async function withRetry(operation, options = {}) {
     throw new Error(`Operation failed after ${maxAttempts} attempts. Last error: ${lastError.message}`);
 }
 
+/**
+ * Network error patterns to detect connection failures
+ */
+const NETWORK_ERROR_PATTERNS = [
+    'fetch failed',
+    'ECONNREFUSED',
+    'ENOTFOUND',
+    'ETIMEDOUT',
+    'ECONNRESET',
+    'ENETUNREACH',
+    'EHOSTUNREACH',
+    'socket hang up',
+    'network request failed',
+    'Failed to fetch',
+    'getaddrinfo',
+    'connect ECONNREFUSED',
+];
+/**
+ * Checks if an error message indicates a network/connection failure
+ */
+function isNetworkError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    const errorCause = error?.cause?.message?.toLowerCase() || '';
+    return NETWORK_ERROR_PATTERNS.some(pattern => message.includes(pattern.toLowerCase()) ||
+        errorCause.includes(pattern.toLowerCase()));
+}
 /**
  * Wraps errors with additional context and converts them to LangChain errors
  */
 function handleLangChainError(error, context, additionalContext) {
+    // Check for network errors first
+    if (error instanceof Error && isNetworkError(error)) {
+        const endpoint = additionalContext?.endpoint;
+        const provider = additionalContext?.provider;
+        throw new LangChainNetworkError(error.message, endpoint, provider, {
+            originalError: error.name,
+            originalMessage: error.message,
+            stack: error.stack,
+            context,
+            ...additionalContext
+        });
+    }
     // If it's already a LangChain error, re-throw with additional context
     if (error instanceof LangChainError) {
         throw new LangChainExecutionError(`${context}: ${error.message}`, {
@@ -7039,21 +7150,55 @@ You must return ONLY valid JSON that matches the schema exactly. Do not include
     }
 }
 
+/**
+ * Extracts provider and endpoint info from LLM instance if available
+ */
+function extractLlmInfo(llm) {
+    const info = {};
+    // Try to extract provider from class name
+    const className = llm?.constructor?.name || '';
+    if (className.includes('Ollama')) {
+        info.provider = 'ollama';
+        // Try to get baseUrl from ollama instance
+        if ('lc_kwargs' in llm && typeof llm.lc_kwargs === 'object' && llm.lc_kwargs !== null) {
+            const kwargs = llm.lc_kwargs;
+            if (typeof kwargs.baseUrl === 'string') {
+                info.endpoint = kwargs.baseUrl;
+            }
+        }
+    }
+    else if (className.includes('OpenAI')) {
+        info.provider = 'openai';
+    }
+    else if (className.includes('Anthropic')) {
+        info.provider = 'anthropic';
+    }
+    return info;
+}
 /**
  * Executes a LangChain pipeline with the provided LLM, prompt, variables, and parser.
  * @param params - The execution parameters
  * @returns The parsed result from the LLM chain
  * @throws LangChainExecutionError if the chain execution fails or returns empty results
+ * @throws LangChainNetworkError if a network/connection error occurs
  */
-const executeChain = async ({ llm, prompt, variables, parser }) => {
+const executeChain = async ({ llm, prompt, variables, parser, provider, endpoint, }) => {
     validateRequired(llm, 'llm', 'executeChain');
     validateRequired(prompt, 'prompt', 'executeChain');
     validateRequired(variables, 'variables', 'executeChain');
     validateRequired(parser, 'parser', 'executeChain');
     // Validate that variables is an object
     if (typeof variables !== 'object' || Array.isArray(variables)) {
-        throw new LangChainExecutionError('executeChain: Variables must be a non-array object', { variables, type: typeof variables, isArray: Array.isArray(variables) });
+        throw new LangChainExecutionError('executeChain: Variables must be a non-array object', {
+            variables,
+            type: typeof variables,
+            isArray: Array.isArray(variables),
+        });
     }
+    // Extract LLM info for error reporting if not provided
+    const llmInfo = extractLlmInfo(llm);
+    const effectiveProvider = provider || llmInfo.provider;
+    const effectiveEndpoint = endpoint || llmInfo.endpoint;
     try {
         const chain = prompt.pipe(llm).pipe(parser);
         const result = await chain.invoke(variables);
@@ -7064,14 +7209,27 @@ const executeChain = async ({ llm, prompt, variables, parser }) => {
     }
     catch (error) {
         // Re-throw LangChain errors as-is
-        if (error instanceof LangChainExecutionError) {
+        if (error instanceof LangChainExecutionError || error instanceof LangChainNetworkError) {
             throw error;
         }
+        // Check for network errors and throw specific error type
+        if (error instanceof Error && isNetworkError(error)) {
+            throw new LangChainNetworkError(error.message, effectiveEndpoint, effectiveProvider, {
+                originalError: error.name,
+                originalMessage: error.message,
+                stack: error.stack,
+                promptInputVariables: prompt.inputVariables,
+                variableKeys: Object.keys(variables),
+                parserType: parser.constructor.name,
+            });
+        }
         // Wrap other errors with context
         handleLangChainError(error, 'executeChain: Chain execution failed', {
             promptInputVariables: prompt.inputVariables,
             variableKeys: Object.keys(variables),
-            parserType: parser.constructor.name
+            parserType: parser.constructor.name,
+            provider: effectiveProvider,
+            endpoint: effectiveEndpoint,
         });
     }
 };

package/dist/index.js

@@ -68,7 +68,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.27.0";
+const BUILD_VERSION = "0.28.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -248,6 +248,16 @@ class LangChainAuthenticationError extends LangChainError {
         super(message, context);
     }
 }
+/**
+ * Network/connection errors (service unreachable, DNS failures, etc.)
+ */
+class LangChainNetworkError extends LangChainError {
+    constructor(message, endpoint, provider, context) {
+        super(message, { ...context, endpoint, provider });
+        this.endpoint = endpoint;
+        this.provider = provider;
+    }
+}
 
 /**
  * Validates that a required parameter is not null or undefined
@@ -2373,6 +2383,59 @@ class Logger {
     }
 }
 
+/**
+ * Formats a network error with helpful troubleshooting information
+ */
+function formatNetworkError(error, logger) {
+    const endpoint = error.endpoint || 'unknown endpoint';
+    const provider = error.provider || 'LLM service';
+    logger.log('\nFailed to execute command', { color: 'yellow' });
+    logger.log(`\nError: Unable to connect to ${provider}`, { color: 'red' });
+    if (error.endpoint) {
+        logger.log(`       Endpoint: ${endpoint}`, { color: 'red' });
+    }
+    logger.log('\nTroubleshooting:', { color: 'cyan' });
+    // Provider-specific troubleshooting
+    if (provider === 'ollama' || endpoint.includes('11434')) {
+        logger.log('  • Is Ollama running? Try: ollama serve', { color: 'white' });
+        logger.log('  • Check if the endpoint is correct in your config', { color: 'white' });
+        logger.log(`  • Verify Ollama is accessible: curl ${endpoint}/api/version`, { color: 'white' });
+    }
+    else if (provider === 'openai' || endpoint.includes('openai')) {
+        logger.log('  • Check your internet connection', { color: 'white' });
+        logger.log('  • Verify the API endpoint is accessible', { color: 'white' });
+        logger.log('  • If using a custom baseURL, verify it is correct', { color: 'white' });
+    }
+    else if (provider === 'anthropic') {
+        logger.log('  • Check your internet connection', { color: 'white' });
+        logger.log('  • Verify the Anthropic API is accessible', { color: 'white' });
+    }
+    else {
+        logger.log('  • Check your internet connection', { color: 'white' });
+        logger.log('  • Verify the service endpoint is correct', { color: 'white' });
+        logger.log('  • Ensure the LLM service is running and accessible', { color: 'white' });
+    }
+    logger.verbose(`\nOriginal error: ${error.message}`, { color: 'gray' });
+}
+/**
+ * Formats an authentication error with helpful information
+ */
+function formatAuthenticationError(error, logger) {
+    logger.log('\nFailed to execute command', { color: 'yellow' });
+    logger.log('\nError: Authentication failed', { color: 'red' });
+    logger.log('\nTroubleshooting:', { color: 'cyan' });
+    logger.log('  • Verify your API key is correct', { color: 'white' });
+    logger.log('  • Check that your API key has not expired', { color: 'white' });
+    logger.log('  • Ensure the API key is set in your environment or config', { color: 'white' });
+    logger.verbose(`\nOriginal error: ${error.message}`, { color: 'gray' });
+}
+/**
+ * Formats a generic error
+ */
+function formatGenericError(error, logger) {
+    logger.log('\nFailed to execute command', { color: 'yellow' });
+    logger.verbose(`\nError: "${error.message}"`, { color: 'red' });
+}
 function commandExecutor(handler) {
     return async (argv) => {
         const options = loadConfig(argv);
@@ -2381,8 +2444,16 @@ function commandExecutor(handler) {
             await handler(argv, logger);
         }
         catch (error) {
-            logger.log('\nFailed to execute command', { color: 'yellow' });
-            logger.verbose(`\nError: "${error.message}"`, { color: 'red' });
+            // Handle specific error types with helpful messages
+            if (error instanceof LangChainNetworkError) {
+                formatNetworkError(error, logger);
+            }
+            else if (error instanceof LangChainAuthenticationError) {
+                formatAuthenticationError(error, logger);
+            }
+            else {
+                formatGenericError(error, logger);
+            }
             logger.log('\nThanks for using coco, make it a great day! 👋🤖', { color: 'blue' });
             process.exit(0);
         }
@@ -6274,10 +6345,50 @@ async function withRetry(operation, options = {}) {
     throw new Error(`Operation failed after ${maxAttempts} attempts. Last error: ${lastError.message}`);
 }
 
+/**
+ * Network error patterns to detect connection failures
+ */
+const NETWORK_ERROR_PATTERNS = [
+    'fetch failed',
+    'ECONNREFUSED',
+    'ENOTFOUND',
+    'ETIMEDOUT',
+    'ECONNRESET',
+    'ENETUNREACH',
+    'EHOSTUNREACH',
+    'socket hang up',
+    'network request failed',
+    'Failed to fetch',
+    'getaddrinfo',
+    'connect ECONNREFUSED',
+];
+/**
+ * Checks if an error message indicates a network/connection failure
+ */
+function isNetworkError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    const errorCause = error?.cause?.message?.toLowerCase() || '';
+    return NETWORK_ERROR_PATTERNS.some(pattern => message.includes(pattern.toLowerCase()) ||
+        errorCause.includes(pattern.toLowerCase()));
+}
 /**
  * Wraps errors with additional context and converts them to LangChain errors
  */
 function handleLangChainError(error, context, additionalContext) {
+    // Check for network errors first
+    if (error instanceof Error && isNetworkError(error)) {
+        const endpoint = additionalContext?.endpoint;
+        const provider = additionalContext?.provider;
+        throw new LangChainNetworkError(error.message, endpoint, provider, {
+            originalError: error.name,
+            originalMessage: error.message,
+            stack: error.stack,
+            context,
+            ...additionalContext
+        });
+    }
     // If it's already a LangChain error, re-throw with additional context
     if (error instanceof LangChainError) {
         throw new LangChainExecutionError(`${context}: ${error.message}`, {
@@ -7061,21 +7172,55 @@ You must return ONLY valid JSON that matches the schema exactly. Do not include
     }
 }
 
+/**
+ * Extracts provider and endpoint info from LLM instance if available
+ */
+function extractLlmInfo(llm) {
+    const info = {};
+    // Try to extract provider from class name
+    const className = llm?.constructor?.name || '';
+    if (className.includes('Ollama')) {
+        info.provider = 'ollama';
+        // Try to get baseUrl from ollama instance
+        if ('lc_kwargs' in llm && typeof llm.lc_kwargs === 'object' && llm.lc_kwargs !== null) {
+            const kwargs = llm.lc_kwargs;
+            if (typeof kwargs.baseUrl === 'string') {
+                info.endpoint = kwargs.baseUrl;
+            }
+        }
+    }
+    else if (className.includes('OpenAI')) {
+        info.provider = 'openai';
+    }
+    else if (className.includes('Anthropic')) {
+        info.provider = 'anthropic';
+    }
+    return info;
+}
 /**
  * Executes a LangChain pipeline with the provided LLM, prompt, variables, and parser.
  * @param params - The execution parameters
  * @returns The parsed result from the LLM chain
  * @throws LangChainExecutionError if the chain execution fails or returns empty results
+ * @throws LangChainNetworkError if a network/connection error occurs
  */
-const executeChain = async ({ llm, prompt, variables, parser }) => {
+const executeChain = async ({ llm, prompt, variables, parser, provider, endpoint, }) => {
     validateRequired(llm, 'llm', 'executeChain');
     validateRequired(prompt, 'prompt', 'executeChain');
     validateRequired(variables, 'variables', 'executeChain');
     validateRequired(parser, 'parser', 'executeChain');
     // Validate that variables is an object
     if (typeof variables !== 'object' || Array.isArray(variables)) {
-        throw new LangChainExecutionError('executeChain: Variables must be a non-array object', { variables, type: typeof variables, isArray: Array.isArray(variables) });
+        throw new LangChainExecutionError('executeChain: Variables must be a non-array object', {
+            variables,
+            type: typeof variables,
+            isArray: Array.isArray(variables),
+        });
     }
+    // Extract LLM info for error reporting if not provided
+    const llmInfo = extractLlmInfo(llm);
+    const effectiveProvider = provider || llmInfo.provider;
+    const effectiveEndpoint = endpoint || llmInfo.endpoint;
     try {
         const chain = prompt.pipe(llm).pipe(parser);
         const result = await chain.invoke(variables);
@@ -7086,14 +7231,27 @@ const executeChain = async ({ llm, prompt, variables, parser }) => {
     }
     catch (error) {
         // Re-throw LangChain errors as-is
-        if (error instanceof LangChainExecutionError) {
+        if (error instanceof LangChainExecutionError || error instanceof LangChainNetworkError) {
             throw error;
         }
+        // Check for network errors and throw specific error type
+        if (error instanceof Error && isNetworkError(error)) {
+            throw new LangChainNetworkError(error.message, effectiveEndpoint, effectiveProvider, {
+                originalError: error.name,
+                originalMessage: error.message,
+                stack: error.stack,
+                promptInputVariables: prompt.inputVariables,
+                variableKeys: Object.keys(variables),
+                parserType: parser.constructor.name,
+            });
+        }
         // Wrap other errors with context
         handleLangChainError(error, 'executeChain: Chain execution failed', {
             promptInputVariables: prompt.inputVariables,
             variableKeys: Object.keys(variables),
-            parserType: parser.constructor.name
+            parserType: parser.constructor.name,
+            provider: effectiveProvider,
+            endpoint: effectiveEndpoint,
         });
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-coco",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "zero-effort git commits with coco.",
   "author": "gfargo <ghfargo@gmail.com>",
   "license": "MIT",