@eldrforge/kodrdriv 0.0.33 → 0.0.37

package/dist/commands/review.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { Formatter } from '@riotprompt/riotprompt';
+import { ValidationError, FileOperationError, CommandError } from '../error/CommandErrors.js';
 import { getLogger } from '../logging.js';
 import { createCompletion } from '../util/openai.js';
 import { createPrompt } from '../prompt/review.js';
@@ -12,10 +13,171 @@ import { getTimestampedReviewNotesFilename, getOutputPath, getTimestampedRespons
 import { create as create$1 } from '../util/storage.js';
 import path from 'path';
 import os from 'os';
-import { spawnSync } from 'child_process';
+import { spawn } from 'child_process';
 import fs from 'fs/promises';
 
-const execute = async (runConfig)=>{
+// Safe temp file handling with proper permissions and validation
+const createSecureTempFile = async ()=>{
+    const logger = getLogger();
+    const tmpDir = os.tmpdir();
+    // Ensure temp directory exists and is writable
+    try {
+        // Use constant value directly to avoid import restrictions
+        const W_OK = 2; // fs.constants.W_OK value
+        await fs.access(tmpDir, W_OK);
+    } catch (error) {
+        logger.error(`Temp directory not writable: ${tmpDir}`);
+        throw new FileOperationError(`Temp directory not writable: ${error.message}`, tmpDir, error);
+    }
+    const tmpFilePath = path.join(tmpDir, `kodrdriv_review_${Date.now()}_${Math.random().toString(36).substring(7)}.md`);
+    // Create file with restrictive permissions (owner read/write only)
+    try {
+        const fd = await fs.open(tmpFilePath, 'w', 0o600);
+        await fd.close();
+        logger.debug(`Created secure temp file: ${tmpFilePath}`);
+        return tmpFilePath;
+    } catch (error) {
+        logger.error(`Failed to create temp file: ${error.message}`);
+        throw new FileOperationError(`Failed to create temp file: ${error.message}`, 'temporary file', error);
+    }
+};
+// Safe file cleanup with proper error handling
+const cleanupTempFile = async (filePath)=>{
+    const logger = getLogger();
+    try {
+        await fs.unlink(filePath);
+        logger.debug(`Cleaned up temp file: ${filePath}`);
+    } catch (error) {
+        // Only ignore ENOENT (file not found) errors, log others
+        if (error.code !== 'ENOENT') {
+            logger.warn(`Failed to cleanup temp file ${filePath}: ${error.message}`);
+        // Don't throw here to avoid masking the main operation
+        }
+    }
+};
+// Editor with timeout and proper error handling
+const openEditorWithTimeout = async (editorCmd, filePath, timeoutMs = 300000)=>{
+    const logger = getLogger();
+    return new Promise((resolve, reject)=>{
+        logger.debug(`Opening editor: ${editorCmd} ${filePath} (timeout: ${timeoutMs}ms)`);
+        const child = spawn(editorCmd, [
+            filePath
+        ], {
+            stdio: 'inherit',
+            shell: false // Prevent shell injection
+        });
+        const timeout = setTimeout(()=>{
+            logger.warn(`Editor timed out after ${timeoutMs}ms, terminating...`);
+            child.kill('SIGTERM');
+            // Give it a moment to terminate gracefully, then force kill
+            setTimeout(()=>{
+                if (!child.killed) {
+                    logger.warn('Editor did not terminate gracefully, force killing...');
+                    child.kill('SIGKILL');
+                }
+            }, 5000);
+            reject(new Error(`Editor '${editorCmd}' timed out after ${timeoutMs}ms. Consider using a different editor or increasing the timeout.`));
+        }, timeoutMs);
+        child.on('exit', (code, signal)=>{
+            clearTimeout(timeout);
+            logger.debug(`Editor exited with code ${code}, signal ${signal}`);
+            if (signal === 'SIGTERM' || signal === 'SIGKILL') {
+                reject(new Error(`Editor was terminated (${signal})`));
+            } else if (code === 0) {
+                resolve();
+            } else {
+                reject(new Error(`Editor exited with non-zero code: ${code}`));
+            }
+        });
+        child.on('error', (error)=>{
+            clearTimeout(timeout);
+            logger.error(`Editor error: ${error.message}`);
+            reject(new Error(`Failed to launch editor '${editorCmd}': ${error.message}`));
+        });
+    });
+};
+// Validate API response format before use
+const validateReviewResult = (data)=>{
+    if (!data || typeof data !== 'object') {
+        throw new Error('Invalid API response: expected object, got ' + typeof data);
+    }
+    if (typeof data.summary !== 'string') {
+        throw new Error('Invalid API response: missing or invalid summary field');
+    }
+    if (typeof data.totalIssues !== 'number' || data.totalIssues < 0) {
+        throw new Error('Invalid API response: missing or invalid totalIssues field');
+    }
+    if (data.issues && !Array.isArray(data.issues)) {
+        throw new Error('Invalid API response: issues field must be an array');
+    }
+    // Validate each issue if present
+    if (data.issues) {
+        for(let i = 0; i < data.issues.length; i++){
+            const issue = data.issues[i];
+            if (!issue || typeof issue !== 'object') {
+                throw new Error(`Invalid API response: issue ${i} is not an object`);
+            }
+            if (typeof issue.title !== 'string') {
+                throw new Error(`Invalid API response: issue ${i} missing title`);
+            }
+            if (typeof issue.priority !== 'string') {
+                throw new Error(`Invalid API response: issue ${i} missing priority`);
+            }
+        }
+    }
+    return data;
+};
+// Enhanced TTY detection with fallback handling
+const isTTYSafe = ()=>{
+    try {
+        // Primary check
+        if (process.stdin.isTTY === false) {
+            return false;
+        }
+        // Additional checks for edge cases
+        if (process.stdin.isTTY === true) {
+            return true;
+        }
+        // Handle undefined case (some environments)
+        if (process.stdin.isTTY === undefined) {
+            // Check if we can reasonably assume interactive mode
+            return process.stdout.isTTY === true && process.stderr.isTTY === true;
+        }
+        return false;
+    } catch (error) {
+        // If TTY detection fails entirely, assume non-interactive
+        getLogger().debug(`TTY detection failed: ${error}, assuming non-interactive`);
+        return false;
+    }
+};
+// Safe file write with disk space and permission validation
+const safeWriteFile = async (filePath, content, encoding = 'utf-8')=>{
+    const logger = getLogger();
+    try {
+        // Check if parent directory exists and is writable
+        const parentDir = path.dirname(filePath);
+        const W_OK = 2; // fs.constants.W_OK value
+        await fs.access(parentDir, W_OK);
+        // Check available disk space (basic check by writing a small test)
+        const testFile = `${filePath}.test`;
+        try {
+            await fs.writeFile(testFile, 'test', encoding);
+            await fs.unlink(testFile);
+        } catch (error) {
+            if (error.code === 'ENOSPC') {
+                throw new Error(`Insufficient disk space to write file: ${filePath}`);
+            }
+            throw error;
+        }
+        // Write the actual file
+        await fs.writeFile(filePath, content, encoding);
+        logger.debug(`Successfully wrote file: ${filePath} (${content.length} characters)`);
+    } catch (error) {
+        logger.error(`Failed to write file ${filePath}: ${error.message}`);
+        throw new Error(`Failed to write file ${filePath}: ${error.message}`);
+    }
+};
+const executeInternal = async (runConfig)=>{
     var _runConfig_review, _runConfig_review1, _runConfig_review2, _runConfig_review3, _runConfig_review4, _runConfig_review5, _runConfig_review6, _runConfig_review7, _runConfig_review8, _runConfig_review9, _runConfig_review10, _runConfig_review11, _runConfig_review12, _runConfig_review13, _runConfig_review14, _runConfig_review_context, _runConfig_review15, _runConfig_review16, _analysisResult_issues, _runConfig_review17;
     const logger = getLogger();
     const isDryRun = runConfig.dryRun || false;
@@ -50,68 +212,70 @@ const execute = async (runConfig)=>{
         }
         return 'DRY RUN: Review command would analyze note, gather context, and create GitHub issues';
     }
-    // Fail fast if STDIN is piped but sendit mode is not enabled
-    if (!process.stdin.isTTY && !((_runConfig_review9 = runConfig.review) === null || _runConfig_review9 === void 0 ? void 0 : _runConfig_review9.sendit)) {
+    // Enhanced TTY check with proper error handling
+    const isInteractive = isTTYSafe();
+    if (!isInteractive && !((_runConfig_review9 = runConfig.review) === null || _runConfig_review9 === void 0 ? void 0 : _runConfig_review9.sendit)) {
         logger.error('❌ STDIN is piped but --sendit flag is not enabled');
         logger.error('   Interactive prompts cannot be used when input is piped');
         logger.error('   Solutions:');
         logger.error('   • Add --sendit flag to auto-create all issues');
         logger.error('   • Use terminal input instead of piping');
         logger.error('   • Example: echo "note" | kodrdriv review --sendit');
-        throw new Error('Piped input requires --sendit flag for non-interactive operation');
+        throw new ValidationError('Piped input requires --sendit flag for non-interactive operation');
     }
     // Get the review note from configuration
     let reviewNote = (_runConfig_review10 = runConfig.review) === null || _runConfig_review10 === void 0 ? void 0 : _runConfig_review10.note;
     // If no review note was provided via CLI arg or STDIN, open the user's editor to capture it.
     if (!reviewNote || !reviewNote.trim()) {
         const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
-        // Create a temporary file for the user to edit.
-        const tmpDir = os.tmpdir();
-        const tmpFilePath = path.join(tmpDir, `kodrdriv_review_${Date.now()}.md`);
-        // Pre-populate the file with a helpful header so users know what to do.
-        const templateContent = [
-            '# Kodrdriv Review Note',
-            '',
-            '# Please enter your review note below. Lines starting with "#" will be ignored.',
-            '# Save and close the editor when you are done.',
-            '',
-            ''
-        ].join('\n');
-        await fs.writeFile(tmpFilePath, templateContent, 'utf8');
-        logger.info(`No review note provided – opening ${editor} to capture input...`);
-        // Open the editor synchronously so execution resumes after the user closes it.
-        const result = spawnSync(editor, [
-            tmpFilePath
-        ], {
-            stdio: 'inherit'
-        });
-        if (result.error) {
-            throw new Error(`Failed to launch editor '${editor}': ${result.error.message}`);
-        }
-        // Read the file back in, stripping comment lines and whitespace.
-        const fileContent = (await fs.readFile(tmpFilePath, 'utf8')).split('\n').filter((line)=>!line.trim().startsWith('#')).join('\n').trim();
-        // Clean up the temporary file (best-effort – ignore errors).
+        let tmpFilePath = null;
         try {
-            await fs.unlink(tmpFilePath);
-        } catch  {
-        /* ignore */ }
-        if (!fileContent) {
-            throw new Error('Review note is empty – aborting. Provide a note as an argument, via STDIN, or through the editor.');
-        }
-        reviewNote = fileContent;
-        // If the original runConfig.review object exists, update it so downstream code has the note.
-        if (runConfig.review) {
-            runConfig.review.note = reviewNote;
+            var _runConfig_review20;
+            // Create secure temporary file
+            tmpFilePath = await createSecureTempFile();
+            // Pre-populate the file with a helpful header so users know what to do.
+            const templateContent = [
+                '# Kodrdriv Review Note',
+                '',
+                '# Please enter your review note below. Lines starting with "#" will be ignored.',
+                '# Save and close the editor when you are done.',
+                '',
+                ''
+            ].join('\n');
+            await safeWriteFile(tmpFilePath, templateContent);
+            logger.info(`No review note provided – opening ${editor} to capture input...`);
+            // Open the editor with timeout protection
+            const editorTimeout = ((_runConfig_review20 = runConfig.review) === null || _runConfig_review20 === void 0 ? void 0 : _runConfig_review20.editorTimeout) || 300000; // 5 minutes default
+            await openEditorWithTimeout(editor, tmpFilePath, editorTimeout);
+            // Read the file back in, stripping comment lines and whitespace.
+            const fileContent = (await fs.readFile(tmpFilePath, 'utf8')).split('\n').filter((line)=>!line.trim().startsWith('#')).join('\n').trim();
+            if (!fileContent) {
+                throw new ValidationError('Review note is empty – aborting. Provide a note as an argument, via STDIN, or through the editor.');
+            }
+            reviewNote = fileContent;
+            // If the original runConfig.review object exists, update it so downstream code has the note.
+            if (runConfig.review) {
+                runConfig.review.note = reviewNote;
+            }
+        } catch (error) {
+            logger.error(`Failed to capture review note via editor: ${error.message}`);
+            throw error;
+        } finally{
+            // Always clean up the temp file
+            if (tmpFilePath) {
+                await cleanupTempFile(tmpFilePath);
+            }
         }
     }
     logger.info('📝 Starting review analysis...');
     logger.debug('Review note: %s', reviewNote);
     logger.debug('Review note length: %d characters', reviewNote.length);
-    // Gather additional context based on configuration
+    // Gather additional context based on configuration with improved error handling
     let logContext = '';
     let diffContext = '';
     let releaseNotesContext = '';
     let issuesContext = '';
+    const contextErrors = [];
     // Fetch commit history if enabled
     if ((_runConfig_review11 = runConfig.review) === null || _runConfig_review11 === void 0 ? void 0 : _runConfig_review11.includeCommitHistory) {
         try {
@@ -125,7 +289,9 @@ const execute = async (runConfig)=>{
                 logger.debug('Added commit history to context (%d characters)', logContent.length);
             }
         } catch (error) {
-            logger.warn('Failed to fetch commit history: %s', error.message);
+            const errorMsg = `Failed to fetch commit history: ${error.message}`;
+            logger.warn(errorMsg);
+            contextErrors.push(errorMsg);
         }
     }
     // Fetch recent diffs if enabled
@@ -139,8 +305,13 @@ const execute = async (runConfig)=>{
                 baseExcludedPatterns: basePatterns
             });
             diffContext += recentDiffs;
+            if (recentDiffs.trim()) {
+                logger.debug('Added recent diffs to context (%d characters)', recentDiffs.length);
+            }
         } catch (error) {
-            logger.warn('Failed to fetch recent diffs: %s', error.message);
+            const errorMsg = `Failed to fetch recent diffs: ${error.message}`;
+            logger.warn(errorMsg);
+            contextErrors.push(errorMsg);
         }
     }
     // Fetch release notes if enabled
@@ -155,7 +326,9 @@ const execute = async (runConfig)=>{
                 logger.debug('Added release notes to context (%d characters)', releaseNotesContent.length);
             }
         } catch (error) {
-            logger.warn('Failed to fetch release notes: %s', error.message);
+            const errorMsg = `Failed to fetch release notes: ${error.message}`;
+            logger.warn(errorMsg);
+            contextErrors.push(errorMsg);
         }
     }
     // Fetch GitHub issues if enabled
@@ -165,9 +338,24 @@ const execute = async (runConfig)=>{
             issuesContext = await get$1({
                 limit: runConfig.review.githubIssuesLimit || 20
             });
-            logger.debug('Added GitHub issues to context (%d characters)', issuesContext.length);
+            if (issuesContext.trim()) {
+                logger.debug('Added GitHub issues to context (%d characters)', issuesContext.length);
+            }
         } catch (error) {
-            logger.warn('Failed to fetch GitHub issues: %s', error.message);
+            const errorMsg = `Failed to fetch GitHub issues: ${error.message}`;
+            logger.warn(errorMsg);
+            contextErrors.push(errorMsg);
+        }
+    }
+    // Report context gathering results
+    if (contextErrors.length > 0) {
+        var _runConfig_review21;
+        logger.warn(`Context gathering completed with ${contextErrors.length} error(s):`);
+        contextErrors.forEach((error)=>logger.warn(`  - ${error}`));
+        // For critical operations, consider failing if too many context sources fail
+        const maxContextErrors = ((_runConfig_review21 = runConfig.review) === null || _runConfig_review21 === void 0 ? void 0 : _runConfig_review21.maxContextErrors) || contextErrors.length; // Default: allow all errors
+        if (contextErrors.length > maxContextErrors) {
+            throw new Error(`Too many context gathering errors (${contextErrors.length}), aborting review. Consider checking your configuration and network connectivity.`);
         }
     }
     // Analyze review note for issues using OpenAI
@@ -201,7 +389,7 @@ const execute = async (runConfig)=>{
     await storage.ensureDirectory(outputDirectory);
     // Save timestamped copy of review notes and context to output directory
     try {
-        var _runConfig_review_context1, _runConfig_review20;
+        var _runConfig_review_context1, _runConfig_review22;
         // Save the original review note
         const reviewNotesFilename = getTimestampedReviewNotesFilename();
         const reviewNotesPath = getOutputPath(outputDirectory, reviewNotesFilename);
@@ -219,26 +407,35 @@ const execute = async (runConfig)=>{
         if (issuesContext.trim()) {
             reviewNotesContent += `# GitHub Issues Context\n\n${issuesContext}\n\n`;
         }
-        if ((_runConfig_review20 = runConfig.review) === null || _runConfig_review20 === void 0 ? void 0 : (_runConfig_review_context1 = _runConfig_review20.context) === null || _runConfig_review_context1 === void 0 ? void 0 : _runConfig_review_context1.trim()) {
+        if ((_runConfig_review22 = runConfig.review) === null || _runConfig_review22 === void 0 ? void 0 : (_runConfig_review_context1 = _runConfig_review22.context) === null || _runConfig_review_context1 === void 0 ? void 0 : _runConfig_review_context1.trim()) {
             reviewNotesContent += `# User Context\n\n${runConfig.review.context}\n\n`;
         }
-        await storage.writeFile(reviewNotesPath, reviewNotesContent, 'utf-8');
+        await safeWriteFile(reviewNotesPath, reviewNotesContent);
         logger.debug('Saved timestamped review notes and context: %s', reviewNotesPath);
     } catch (error) {
         logger.warn('Failed to save timestamped review notes: %s', error.message);
+    // Don't fail the entire operation for this
     }
     const request = Formatter.create({
         logger
     }).formatPrompt(runConfig.model, prompt);
-    const analysisResult = await createCompletion(request.messages, {
-        model: runConfig.model,
-        responseFormat: {
-            type: 'json_object'
-        },
-        debug: runConfig.debug,
-        debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('review-analysis')),
-        debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('review-analysis'))
-    });
+    let analysisResult;
+    try {
+        const rawResult = await createCompletion(request.messages, {
+            model: runConfig.model,
+            responseFormat: {
+                type: 'json_object'
+            },
+            debug: runConfig.debug,
+            debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('review-analysis')),
+            debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('review-analysis'))
+        });
+        // Validate the API response before using it
+        analysisResult = validateReviewResult(rawResult);
+    } catch (error) {
+        logger.error(`Failed to analyze review note: ${error.message}`);
+        throw new Error(`Review analysis failed: ${error.message}`);
+    }
     logger.info('✅ Analysis completed');
     logger.debug('Analysis result summary: %s', analysisResult.summary);
     logger.debug('Total issues found: %d', analysisResult.totalIssues);
@@ -254,15 +451,44 @@ const execute = async (runConfig)=>{
         const reviewPath = getOutputPath(outputDirectory, reviewFilename);
         // Format the analysis result as markdown
         const reviewContent = `# Review Analysis Result\n\n` + `## Summary\n${analysisResult.summary}\n\n` + `## Total Issues Found\n${analysisResult.totalIssues}\n\n` + `## Issues\n\n${JSON.stringify(analysisResult.issues, null, 2)}\n\n` + `---\n\n*Analysis completed at ${new Date().toISOString()}*`;
-        await storage.writeFile(reviewPath, reviewContent, 'utf-8');
+        await safeWriteFile(reviewPath, reviewContent);
         logger.debug('Saved timestamped review analysis: %s', reviewPath);
     } catch (error) {
         logger.warn('Failed to save timestamped review analysis: %s', error.message);
+    // Don't fail the entire operation for this
     }
     // Handle GitHub issue creation using the issues module
     const senditMode = ((_runConfig_review17 = runConfig.review) === null || _runConfig_review17 === void 0 ? void 0 : _runConfig_review17.sendit) || false;
     return await handleIssueCreation(analysisResult, senditMode);
 };
+const execute = async (runConfig)=>{
+    try {
+        return await executeInternal(runConfig);
+    } catch (error) {
+        const logger = getLogger();
+        if (error instanceof ValidationError) {
+            logger.error(`review failed: ${error.message}`);
+            process.exit(1);
+        }
+        if (error instanceof FileOperationError) {
+            logger.error(`review failed: ${error.message}`);
+            if (error.cause) {
+                logger.debug(`Caused by: ${error.cause.message}`);
+            }
+            process.exit(1);
+        }
+        if (error instanceof CommandError) {
+            logger.error(`review failed: ${error.message}`);
+            if (error.cause) {
+                logger.debug(`Caused by: ${error.cause.message}`);
+            }
+            process.exit(1);
+        }
+        // Unexpected errors
+        logger.error(`review encountered unexpected error: ${error.message}`);
+        process.exit(1);
+    }
+};
 
 export { execute };
 //# sourceMappingURL=review.js.map