@eldrforge/kodrdriv 1.2.21 → 1.2.22

package/dist/commands/review.js

@@ -2,26 +2,27 @@
 import { Formatter } from '@riotprompt/riotprompt';
 import { ValidationError, FileOperationError, CommandError } from '../error/CommandErrors.js';
 import { getLogger } from '../logging.js';
-import { getModelForCommand, createCompletion, getOpenAIMaxOutputTokensForCommand, getOpenAIReasoningForCommand } from '../util/openai.js';
-import { createPrompt } from '../prompt/review.js';
+import { getUserChoice, createReviewPrompt, createCompletion } from '@eldrforge/ai-service';
+import { toAIConfig } from '../util/aiAdapter.js';
+import { createStorageAdapter } from '../util/storageAdapter.js';
+import { createLoggerAdapter } from '../util/loggerAdapter.js';
 import { create as create$1 } from '../content/log.js';
 import { getReviewExcludedPatterns, getRecentDiffsForReview } from '../content/diff.js';
 import { handleIssueCreation, getReleaseNotesContent, getIssuesContent } from '@eldrforge/github-tools';
 import { DEFAULT_EXCLUDED_PATTERNS, DEFAULT_OUTPUT_DIRECTORY } from '../constants.js';
 import { getTimestampedReviewNotesFilename, getOutputPath, getTimestampedReviewFilename, getTimestampedResponseFilename, getTimestampedRequestFilename } from '../util/general.js';
 import { create } from '../util/storage.js';
-import { getUserChoice } from '../util/interactive.js';
-import path__default from 'path';
-import os__default from 'os';
+import path from 'path';
+import os from 'os';
 import { spawn } from 'child_process';
-import fs__default from 'fs/promises';
+import fs from 'fs/promises';
 
 // Utility function to read a review note from a file
 const readReviewNoteFromFile = async (filePath)=>{
     const logger = getLogger();
     try {
         logger.debug(`Reading review note from file: ${filePath}`);
-        const content = await fs__default.readFile(filePath, 'utf8');
+        const content = await fs.readFile(filePath, 'utf8');
         if (!content.trim()) {
             throw new ValidationError(`Review file is empty: ${filePath}`);
         }
@@ -42,11 +43,11 @@ const getReviewFilesInDirectory = async (directoryPath)=>{
     const logger = getLogger();
     try {
         logger.debug(`Scanning directory for review files: ${directoryPath}`);
-        const entries = await fs__default.readdir(directoryPath, {
+        const entries = await fs.readdir(directoryPath, {
             withFileTypes: true
         });
         // Filter for regular files (not directories) and get full paths
-        const files = entries.filter((entry)=>entry.isFile()).map((entry)=>path__default.join(directoryPath, entry.name)).sort(); // Sort alphabetically
+        const files = entries.filter((entry)=>entry.isFile()).map((entry)=>path.join(directoryPath, entry.name)).sort(); // Sort alphabetically
         logger.debug(`Found ${files.length} files in directory: ${directoryPath}`);
         return files;
     } catch (error) {
@@ -120,20 +121,20 @@ const selectFilesForProcessing = async (reviewFiles, senditMode)=>{
 // Safe temp file handling with proper permissions and validation
 const createSecureTempFile = async ()=>{
     const logger = getLogger();
-    const tmpDir = os__default.tmpdir();
+    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__default.access(tmpDir, W_OK);
+        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__default.join(tmpDir, `kodrdriv_review_${Date.now()}_${Math.random().toString(36).substring(7)}.md`);
+    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__default.open(tmpFilePath, 'w', 0o600);
+        const fd = await fs.open(tmpFilePath, 'w', 0o600);
         await fd.close();
         logger.debug(`Created secure temp file: ${tmpFilePath}`);
         return tmpFilePath;
@@ -146,7 +147,7 @@ const createSecureTempFile = async ()=>{
 const cleanupTempFile = async (filePath)=>{
     const logger = getLogger();
     try {
-        await fs__default.unlink(filePath);
+        await fs.unlink(filePath);
         logger.debug(`Cleaned up temp file: ${filePath}`);
     } catch (error) {
         // Only ignore ENOENT (file not found) errors, log others
@@ -271,14 +272,14 @@ const safeWriteFile = async (filePath, content, encoding = 'utf-8')=>{
     const logger = getLogger();
     try {
         // Check if parent directory exists and is writable
-        const parentDir = path__default.dirname(filePath);
+        const parentDir = path.dirname(filePath);
         const W_OK = 2; // fs.constants.W_OK value
-        await fs__default.access(parentDir, W_OK);
+        await fs.access(parentDir, W_OK);
         // Check available disk space (basic check by writing a small test)
         const testFile = `${filePath}.test`;
         try {
-            await fs__default.writeFile(testFile, 'test', encoding);
-            await fs__default.unlink(testFile);
+            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}`);
@@ -286,7 +287,7 @@ const safeWriteFile = async (filePath, content, encoding = 'utf-8')=>{
             throw error;
         }
         // Write the actual file
-        await fs__default.writeFile(filePath, content, encoding);
+        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}`);
@@ -295,7 +296,7 @@ const safeWriteFile = async (filePath, content, encoding = 'utf-8')=>{
 };
 // Helper function to process a single review note
 const processSingleReview = async (reviewNote, runConfig, outputDirectory)=>{
-    var _runConfig_review, _runConfig_review1, _runConfig_review2, _runConfig_review3, _runConfig_review_context, _runConfig_review4, _runConfig_review5, _analysisResult_issues;
+    var _runConfig_review, _runConfig_review1, _runConfig_review2, _runConfig_review3, _runConfig_review_context, _runConfig_review4, _runConfig_review5, _aiConfig_commands_review, _aiConfig_commands, _analysisResult_issues;
     const logger = getLogger();
     // Gather additional context based on configuration with improved error handling
     let logContext = '';
@@ -398,6 +399,10 @@ const processSingleReview = async (reviewNote, runConfig, outputDirectory)=>{
         overridePaths: runConfig.discoveredConfigDirs || [],
         overrides: runConfig.overrides || false
     };
+    // Create adapters for ai-service
+    const aiConfig = toAIConfig(runConfig);
+    const aiStorageAdapter = createStorageAdapter();
+    const aiLogger = createLoggerAdapter(runConfig.dryRun || false);
     const promptContent = {
         notes: reviewNote
     };
@@ -408,23 +413,25 @@ const processSingleReview = async (reviewNote, runConfig, outputDirectory)=>{
         releaseNotesContext,
         issuesContext
     };
-    const prompt = await createPrompt(promptConfig, promptContent, promptContext);
-    const modelToUse = getModelForCommand(runConfig, 'review');
+    const prompt = await createReviewPrompt(promptConfig, promptContent, promptContext);
+    const modelToUse = ((_aiConfig_commands = aiConfig.commands) === null || _aiConfig_commands === void 0 ? void 0 : (_aiConfig_commands_review = _aiConfig_commands.review) === null || _aiConfig_commands_review === void 0 ? void 0 : _aiConfig_commands_review.model) || aiConfig.model || 'gpt-4o-mini';
     const request = Formatter.create({
         logger
     }).formatPrompt(modelToUse, prompt);
     let analysisResult;
     try {
+        var _aiConfig_commands_review1, _aiConfig_commands1;
         const rawResult = await createCompletion(request.messages, {
             model: modelToUse,
-            openaiReasoning: getOpenAIReasoningForCommand(runConfig, 'review'),
-            openaiMaxOutputTokens: getOpenAIMaxOutputTokensForCommand(runConfig, 'review'),
+            openaiReasoning: ((_aiConfig_commands1 = aiConfig.commands) === null || _aiConfig_commands1 === void 0 ? void 0 : (_aiConfig_commands_review1 = _aiConfig_commands1.review) === null || _aiConfig_commands_review1 === void 0 ? void 0 : _aiConfig_commands_review1.reasoning) || aiConfig.reasoning,
             responseFormat: {
                 type: 'json_object'
             },
             debug: runConfig.debug,
             debugRequestFile: getOutputPath(outputDirectory, getTimestampedRequestFilename('review-analysis')),
-            debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('review-analysis'))
+            debugResponseFile: getOutputPath(outputDirectory, getTimestampedResponseFilename('review-analysis')),
+            storage: aiStorageAdapter,
+            logger: aiLogger
         });
         // Validate the API response before using it
         analysisResult = validateReviewResult(rawResult);
@@ -566,7 +573,7 @@ const executeInternal = async (runConfig)=>{
             const editorTimeout = (_runConfig_review25 = runConfig.review) === null || _runConfig_review25 === void 0 ? void 0 : _runConfig_review25.editorTimeout; // No default timeout - let user take their time
             await openEditorWithTimeout(editor, tmpFilePath, editorTimeout);
             // Read the file back in, stripping comment lines and whitespace.
-            const fileContent = (await fs__default.readFile(tmpFilePath, 'utf8')).split('\n').filter((line)=>!line.trim().startsWith('#')).join('\n').trim();
+            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.');
             }