threadlines 0.4.0 → 0.6.0

package/dist/commands/check.js

@@ -97,29 +97,66 @@ async function checkCommand(options) {
         logger_1.logger.error('Not a git repository. Threadline requires a git repository.');
         process.exit(1);
     }
-    // Pre-flight check: Validate OpenAI API key is set (required for local processing)
+    // Determine which LLM provider to use based on configuration
+    // Explicit provider selection (not a fallback pattern)
+    const bedrockConfig = (0, config_1.getBedrockConfig)(config);
     const openAIConfig = (0, config_1.getOpenAIConfig)(config);
-    if (!openAIConfig) {
-        logger_1.logger.error('Missing required environment variable: OPENAI_API_KEY');
+    let provider;
+    let bedrockConfigToUse;
+    let openAIConfigToUse;
+    // Explicit provider selection: handle all cases clearly
+    if (bedrockConfig && openAIConfig) {
+        // Both configured: use Bedrock (explicit priority)
+        logger_1.logger.warn('Both Bedrock and OpenAI are configured. Using Bedrock (priority provider).');
+        provider = 'bedrock';
+        bedrockConfigToUse = bedrockConfig;
+        openAIConfigToUse = undefined;
+        (0, config_1.logBedrockConfig)(bedrockConfig);
+    }
+    else if (bedrockConfig) {
+        // Only Bedrock configured: use Bedrock
+        provider = 'bedrock';
+        bedrockConfigToUse = bedrockConfig;
+        openAIConfigToUse = undefined;
+        (0, config_1.logBedrockConfig)(bedrockConfig);
+    }
+    else if (openAIConfig) {
+        // Only OpenAI configured: use OpenAI
+        provider = 'openai';
+        bedrockConfigToUse = undefined;
+        openAIConfigToUse = openAIConfig;
+        (0, config_1.logOpenAIConfig)(openAIConfig);
+    }
+    else {
+        // Neither configured: fail loudly
+        logger_1.logger.error('Missing required LLM provider configuration');
         logger_1.logger.output('');
-        logger_1.logger.output(chalk_1.default.yellow('To fix this:'));
+        logger_1.logger.output(chalk_1.default.yellow('You need to configure either Bedrock or OpenAI:'));
         logger_1.logger.output('');
-        logger_1.logger.output(chalk_1.default.white('  Local development:'));
-        logger_1.logger.output(chalk_1.default.gray('    1. Create a .env.local file in your project root'));
-        logger_1.logger.output(chalk_1.default.gray('    2. Add: OPENAI_API_KEY=your-openai-api-key'));
-        logger_1.logger.output(chalk_1.default.gray('    3. Make sure .env.local is in your .gitignore'));
+        logger_1.logger.output(chalk_1.default.white('  Option 1: Amazon Bedrock'));
+        logger_1.logger.output(chalk_1.default.gray('    Local development:'));
+        logger_1.logger.output(chalk_1.default.gray('      1. Create a .env.local file in your project root'));
+        logger_1.logger.output(chalk_1.default.gray('      2. Add: BEDROCK_ACCESS_KEY_ID=your-access-key-id'));
+        logger_1.logger.output(chalk_1.default.gray('      3. Add: BEDROCK_SECRET_ACCESS_KEY=your-secret-access-key'));
+        logger_1.logger.output(chalk_1.default.gray('      4. Ensure .threadlinerc contains: bedrock_model and bedrock_region'));
+        logger_1.logger.output(chalk_1.default.gray('    CI/CD: Add BEDROCK_ACCESS_KEY_ID and BEDROCK_SECRET_ACCESS_KEY as secrets'));
+        logger_1.logger.output(chalk_1.default.gray('           Ensure .threadlinerc contains: bedrock_model and bedrock_region'));
         logger_1.logger.output('');
-        logger_1.logger.output(chalk_1.default.white('  CI/CD:'));
-        logger_1.logger.output(chalk_1.default.gray('    GitHub Actions:     Settings → Secrets → Add OPENAI_API_KEY'));
-        logger_1.logger.output(chalk_1.default.gray('    GitLab CI:          Settings → CI/CD → Variables → Add OPENAI_API_KEY'));
-        logger_1.logger.output(chalk_1.default.gray('    Bitbucket Pipelines: Repository settings → Repository variables → Add OPENAI_API_KEY'));
-        logger_1.logger.output(chalk_1.default.gray('    Vercel:             Settings → Environment Variables → Add OPENAI_API_KEY'));
+        logger_1.logger.output(chalk_1.default.white('  Option 2: OpenAI'));
+        logger_1.logger.output(chalk_1.default.gray('    Local development:'));
+        logger_1.logger.output(chalk_1.default.gray('      1. Create a .env.local file in your project root'));
+        logger_1.logger.output(chalk_1.default.gray('      2. Add: OPENAI_API_KEY=your-openai-api-key'));
+        logger_1.logger.output(chalk_1.default.gray('      3. Ensure .threadlinerc contains: openai_model and openai_service_tier'));
+        logger_1.logger.output(chalk_1.default.gray('    CI/CD:'));
+        logger_1.logger.output(chalk_1.default.gray('      GitHub Actions:     Settings → Secrets → Add OPENAI_API_KEY'));
+        logger_1.logger.output(chalk_1.default.gray('      GitLab CI:          Settings → CI/CD → Variables → Add OPENAI_API_KEY'));
+        logger_1.logger.output(chalk_1.default.gray('      Bitbucket Pipelines: Repository settings → Repository variables → Add OPENAI_API_KEY'));
+        logger_1.logger.output(chalk_1.default.gray('      Vercel:             Settings → Environment Variables → Add OPENAI_API_KEY'));
+        logger_1.logger.output(chalk_1.default.gray('      Ensure .threadlinerc contains: openai_model and openai_service_tier'));
         logger_1.logger.output('');
         logger_1.logger.output(chalk_1.default.gray('Get your OpenAI API key at: https://platform.openai.com/api-keys'));
         process.exit(1);
     }
-    // Log OpenAI configuration
-    (0, config_1.logOpenAIConfig)(openAIConfig);
     // 1. Find and validate threadlines
     logger_1.logger.info('Finding threadlines...');
     const threadlines = await (0, experts_1.findThreadlines)(cwd, gitRoot);
@@ -263,7 +300,7 @@ async function checkCommand(options) {
             contextContent
         };
     });
-    // 5. Process threadlines locally using OpenAI
+    // 5. Process threadlines locally using configured LLM provider
     logger_1.logger.info('Running threadline checks...');
     const processResponse = await (0, expert_1.processThreadlines)({
         threadlines: threadlinesWithContext.map(t => ({
@@ -276,9 +313,18 @@ async function checkCommand(options) {
         })),
         diff: gitDiff.diff,
         files: gitDiff.changedFiles,
-        apiKey: openAIConfig.apiKey,
-        model: openAIConfig.model,
-        serviceTier: openAIConfig.serviceTier,
+        provider,
+        bedrockConfig: bedrockConfigToUse ? {
+            accessKeyId: bedrockConfigToUse.accessKeyId,
+            secretAccessKey: bedrockConfigToUse.secretAccessKey,
+            model: bedrockConfigToUse.model,
+            region: bedrockConfigToUse.region
+        } : undefined,
+        openaiConfig: openAIConfigToUse ? {
+            apiKey: openAIConfigToUse.apiKey,
+            model: openAIConfigToUse.model,
+            serviceTier: openAIConfigToUse.serviceTier
+        } : undefined,
         contextLinesForLLM: config.diff_context_lines
     });
     // Convert ProcessThreadlinesResponse to ReviewResponse format for displayResults

package/dist/commands/init.js

@@ -93,6 +93,8 @@ async function initCommand() {
   "api_url": "https://devthreadline.com",
   "openai_model": "gpt-5.2",
   "openai_service_tier": "Flex",
+  "bedrock_model": "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+  "bedrock_region": "us-east-1",
   "diff_context_lines": 10
 }`;
             fs.writeFileSync(configFile, configContent, 'utf-8');
@@ -116,7 +118,12 @@ async function initCommand() {
         logger_1.logger.output(chalk_1.default.white('   To use threadlines check, you need:'));
         logger_1.logger.output('');
         logger_1.logger.output(chalk_1.default.white('   Create a .env.local file in your project root with:'));
+        logger_1.logger.output(chalk_1.default.gray('     // For OpenAI (one of these is required):'));
         logger_1.logger.output(chalk_1.default.gray('     OPENAI_API_KEY=your-openai-api-key'));
+        logger_1.logger.output(chalk_1.default.gray('     // For Bedrock (one of these is required):'));
+        logger_1.logger.output(chalk_1.default.gray('     BEDROCK_ACCESS_KEY_ID=your-access-key-id'));
+        logger_1.logger.output(chalk_1.default.gray('     BEDROCK_SECRET_ACCESS_KEY=your-secret-access-key'));
+        logger_1.logger.output(chalk_1.default.gray('     // For Threadlines sync (required if mode is "online"):'));
         logger_1.logger.output(chalk_1.default.gray('     THREADLINE_API_KEY=your-api-key-here'));
         logger_1.logger.output(chalk_1.default.gray('     THREADLINE_ACCOUNT=your-email@example.com'));
         logger_1.logger.output('');

package/dist/git/local.js

@@ -95,58 +95,38 @@ async function getLocalContext(repoRoot, commitSha) {
  * or review unstaged changes if nothing is staged.
  */
 async function getDiff(repoRoot) {
-    // Get git status in porcelain format to determine what changes exist
-    // Porcelain format: XY filename
-    // X = staged status, Y = unstaged status
-    // ' ' = no change, 'M' = modified, 'A' = added, 'D' = deleted, etc.
-    // '?' = untracked (only in Y position, X is always '?' too)
+    // Use git diff commands as source of truth (more reliable than git status --porcelain)
+    // git status --porcelain can be inconsistent in some edge cases
+    // Check staged files first (source of truth)
+    const stagedFilesOutput = (0, child_process_1.execSync)('git diff --cached --name-only', {
+        encoding: 'utf-8',
+        cwd: repoRoot
+    }).trim();
+    const actualStagedFiles = stagedFilesOutput ? stagedFilesOutput.split('\n') : [];
+    // Check unstaged files (source of truth)
+    const unstagedFilesOutput = (0, child_process_1.execSync)('git diff --name-only', {
+        encoding: 'utf-8',
+        cwd: repoRoot
+    }).trim();
+    const actualUnstagedFiles = unstagedFilesOutput ? unstagedFilesOutput.split('\n') : [];
+    // Get untracked files from git status --porcelain (only reliable way to get untracked)
     const statusOutput = (0, child_process_1.execSync)('git status --porcelain', {
         encoding: 'utf-8',
         cwd: repoRoot
     }).trim();
     const lines = statusOutput ? statusOutput.split('\n') : [];
-    const staged = [];
-    const unstaged = [];
     const untracked = [];
     for (const line of lines) {
         const stagedStatus = line[0];
         const unstagedStatus = line[1];
-        // Collect untracked files separately (they need special handling)
+        // Collect untracked files (only reliable way to detect them)
         if (stagedStatus === '?' && unstagedStatus === '?') {
-            // Format: "?? filename" - skip 3 characters
             const file = line.slice(3);
             untracked.push(file);
-            continue;
-        }
-        // For tracked files, the format can be:
-        // - "M filename" (staged, no leading space) - skip 2 characters
-        // - " M filename" (unstaged, leading space) - skip 3 characters
-        // - "MM filename" (both staged and unstaged) - skip 3 characters
-        let file;
-        if (stagedStatus !== ' ' && unstagedStatus === ' ') {
-            // Staged only: "M filename" - skip 2 characters (M + space)
-            file = line.slice(2);
-        }
-        else {
-            // Unstaged or both: " M filename" or "MM filename" - skip 3 characters
-            file = line.slice(3);
-        }
-        if (stagedStatus !== ' ') {
-            staged.push(file);
-        }
-        if (unstagedStatus !== ' ' && unstagedStatus !== '?') {
-            unstaged.push(file);
         }
     }
     let diff;
     let changedFiles;
-    // Check if there are actually staged files (use git diff as source of truth)
-    // git status parsing can be inconsistent, so we verify with git diff
-    const stagedFilesOutput = (0, child_process_1.execSync)('git diff --cached --name-only', {
-        encoding: 'utf-8',
-        cwd: repoRoot
-    }).trim();
-    const actualStagedFiles = stagedFilesOutput ? stagedFilesOutput.split('\n') : [];
     // Workflow A: Developer has staged files - check ONLY staged files
     // (Ignore unstaged and untracked - developer explicitly chose to check staged)
     if (actualStagedFiles.length > 0) {
@@ -168,27 +148,22 @@ async function getDiff(repoRoot) {
         };
     }
     // No staged files - log clearly and continue to unstaged/untracked
-    if (staged.length > 0) {
-        // git status showed staged files but git diff doesn't - they were likely unstaged
-        logger_1.logger.info(`No staged files detected (files may have been unstaged), checking unstaged/untracked files instead.`);
+    if (actualUnstagedFiles.length > 0 || untracked.length > 0) {
+        logger_1.logger.info(`No staged files, checking unstaged/untracked files.`);
     }
     else {
-        logger_1.logger.info(`No staged files, checking unstaged/untracked files.`);
+        logger_1.logger.info(`No staged files detected.`);
     }
     // Workflow B: Developer hasn't staged files - check unstaged + untracked files
     // (Untracked files are conceptually "unstaged" - files being worked on but not committed)
-    if (unstaged.length > 0 || untracked.length > 0) {
+    if (actualUnstagedFiles.length > 0 || untracked.length > 0) {
         // Get unstaged diff if there are unstaged files
-        if (unstaged.length > 0) {
+        if (actualUnstagedFiles.length > 0) {
             diff = (0, child_process_1.execSync)('git diff -U200', {
                 encoding: 'utf-8',
                 cwd: repoRoot
             });
-            const changedFilesOutput = (0, child_process_1.execSync)('git diff --name-only', {
-                encoding: 'utf-8',
-                cwd: repoRoot
-            }).trim();
-            changedFiles = changedFilesOutput ? changedFilesOutput.split('\n') : [];
+            changedFiles = actualUnstagedFiles;
         }
         else {
             diff = '';
@@ -222,6 +197,14 @@ async function getDiff(repoRoot) {
             ? (diff ? diff + '\n' : '') + untrackedDiffs.join('\n')
             : diff;
         const allChangedFiles = [...changedFiles, ...untrackedFileList];
+        // Validate that we actually have changes to review
+        // This can happen if:
+        // 1. git status showed files but git diff returns empty (files were staged/unstaged between commands)
+        // 2. All untracked items are directories (skipped)
+        // 3. Parsing incorrectly categorized files
+        if (allChangedFiles.length === 0 || !combinedDiff || combinedDiff.trim() === '') {
+            throw new Error('No changes detected. Stage files with "git add" or modify files to run threadlines.');
+        }
         const unstagedCount = changedFiles.length;
         const untrackedCount = untrackedFileList.length;
         if (unstagedCount > 0 && untrackedCount > 0) {
@@ -230,7 +213,7 @@ async function getDiff(repoRoot) {
         else if (unstagedCount > 0) {
             logger_1.logger.info(`Checking UNSTAGED changes (${unstagedCount} file(s))`);
         }
-        else {
+        else if (untrackedCount > 0) {
             logger_1.logger.info(`Checking UNTRACKED files (${untrackedCount} file(s))`);
         }
         return {

package/dist/processors/expert.js

@@ -5,9 +5,18 @@ const single_expert_1 = require("./single-expert");
 const logger_1 = require("../utils/logger");
 const EXPERT_TIMEOUT = 40000; // 40 seconds
 async function processThreadlines(request) {
-    const { threadlines, diff, files, apiKey, model, serviceTier, contextLinesForLLM } = request;
+    const { threadlines, diff, files, provider, bedrockConfig, openaiConfig, contextLinesForLLM } = request;
     // Determine LLM model (same for all threadlines in this check)
-    const llmModel = `${model} ${serviceTier}`;
+    let llmModel;
+    if (provider === 'bedrock' && bedrockConfig) {
+        llmModel = bedrockConfig.model;
+    }
+    else if (provider === 'openai' && openaiConfig) {
+        llmModel = `${openaiConfig.model} ${openaiConfig.serviceTier}`;
+    }
+    else {
+        throw new Error('Invalid provider configuration');
+    }
     // Create promises with timeout
     const promises = threadlines.map(threadline => {
         let timeoutId = null;
@@ -35,7 +44,7 @@ async function processThreadlines(request) {
                 }
             }, EXPERT_TIMEOUT);
         });
-        const actualPromise = (0, single_expert_1.processThreadline)(threadline, diff, files, apiKey, model, serviceTier, contextLinesForLLM).then(result => {
+        const actualPromise = (0, single_expert_1.processThreadline)(threadline, diff, files, provider, bedrockConfig, openaiConfig, contextLinesForLLM).then(result => {
             // Mark as resolved and clear timeout if it hasn't fired yet
             resolved = true;
             if (timeoutId) {
@@ -94,10 +103,15 @@ async function processThreadlines(request) {
             });
         }
     }
-    // Use actual model from OpenAI response, append service tier
+    // Use actual model from response
     let modelToStore;
     if (actualModelFromResponse) {
-        modelToStore = `${actualModelFromResponse} ${serviceTier}`;
+        if (provider === 'openai' && openaiConfig) {
+            modelToStore = `${actualModelFromResponse} ${openaiConfig.serviceTier}`;
+        }
+        else {
+            modelToStore = actualModelFromResponse;
+        }
     }
     else {
         // All calls failed - log prominently and preserve requested model for debugging

package/dist/processors/single-expert.js

@@ -1,11 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processThreadline = processThreadline;
 const prompt_builder_1 = require("../llm/prompt-builder");
 const diff_filter_1 = require("../utils/diff-filter");
 const slim_diff_1 = require("../utils/slim-diff");
 const logger_1 = require("../utils/logger");
-async function processThreadline(threadline, diff, files, apiKey, model, serviceTier, contextLinesForLLM) {
+async function processThreadline(threadline, diff, files, provider, bedrockConfig, openaiConfig, contextLinesForLLM) {
     // Filter files that match threadline patterns
     const relevantFiles = files.filter(file => threadline.patterns.some(pattern => matchesPattern(file, pattern)));
     // If no files match, return not_relevant
@@ -40,8 +73,9 @@ async function processThreadline(threadline, diff, files, apiKey, model, service
     }
     // Build prompt with trimmed diff (full filtered diff is still stored for UI)
     const prompt = (0, prompt_builder_1.buildPrompt)(threadline, trimmedDiffForLLM, filesInFilteredDiff);
+    const modelName = provider === 'bedrock' ? bedrockConfig?.model : openaiConfig?.model;
     logger_1.logger.debug(`   📝 Processing ${threadline.id}: ${relevantFiles.length} relevant files, ${filesInFilteredDiff.length} files in filtered diff`);
-    logger_1.logger.debug(`   🤖 Calling LLM (${model}) for ${threadline.id}...`);
+    logger_1.logger.debug(`   🤖 Calling LLM (${provider}, ${modelName}) for ${threadline.id}...`);
     // Capture timing for LLM call
     const llmCallStartedAt = new Date().toISOString();
     let llmCallFinishedAt;
@@ -50,98 +84,25 @@ async function processThreadline(threadline, diff, files, apiKey, model, service
     let llmCallStatus = 'success';
     let llmCallErrorMessage = null;
     try {
-        // Build request body for OpenAI API (direct HTTP call - zero dependencies)
-        const requestBody = {
-            model,
-            messages: [
-                {
-                    role: 'system',
-                    content: 'You are a code quality checker. Analyze code changes against the threadline guidelines. Be precise - only flag actual violations. Return only valid JSON, no other text.'
-                },
-                {
-                    role: 'user',
-                    content: prompt
-                }
-            ],
-            response_format: { type: 'json_object' },
-            temperature: 0.1
-        };
-        // Add service_tier if not 'standard'
-        const normalizedServiceTier = serviceTier.toLowerCase();
-        if (normalizedServiceTier !== 'standard' && (normalizedServiceTier === 'auto' || normalizedServiceTier === 'default' || normalizedServiceTier === 'flex')) {
-            requestBody.service_tier = normalizedServiceTier;
+        let actualModel;
+        let content;
+        if (provider === 'bedrock' && bedrockConfig) {
+            const bedrockResult = await callBedrockAPI(bedrockConfig, prompt);
+            actualModel = bedrockResult.model;
+            content = bedrockResult.content;
+            llmCallTokens = bedrockResult.tokens;
         }
-        // Direct HTTP call to OpenAI API (native fetch - zero dependencies)
-        // Use AbortController for timeout (higher-level timeout in expert.ts is 40s, use 45s here as safety margin)
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 45000);
-        let httpResponse;
-        try {
-            httpResponse = await fetch('https://api.openai.com/v1/chat/completions', {
-                method: 'POST',
-                headers: {
-                    'Authorization': `Bearer ${apiKey}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(requestBody),
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-        }
-        catch (fetchError) {
-            clearTimeout(timeoutId);
-            // Handle AbortError from timeout
-            if (fetchError instanceof Error && fetchError.name === 'AbortError') {
-                throw new Error('Request timeout');
-            }
-            throw fetchError;
+        else if (provider === 'openai' && openaiConfig) {
+            const openaiResult = await callOpenAIAPI(openaiConfig, prompt);
+            actualModel = openaiResult.model;
+            content = openaiResult.content;
+            llmCallTokens = openaiResult.tokens;
         }
-        if (!httpResponse.ok) {
-            const errorText = await httpResponse.text();
-            let errorMessage = `HTTP ${httpResponse.status}: ${errorText}`;
-            // Try to parse OpenAI error structure
-            try {
-                const errorData = JSON.parse(errorText);
-                if (errorData.error) {
-                    errorMessage = errorData.error.message || errorText;
-                    // Create error object matching SDK error structure for compatibility
-                    const errorObj = new Error(errorMessage);
-                    errorObj.status = httpResponse.status;
-                    errorObj.error = {
-                        type: errorData.error.type,
-                        code: errorData.error.code,
-                        param: errorData.error.param,
-                    };
-                    throw errorObj;
-                }
-            }
-            catch (parseError) {
-                // If it's already our structured error, re-throw it
-                const structuredError = parseError;
-                if (structuredError.status) {
-                    throw parseError;
-                }
-                // Otherwise create a basic error
-                throw new Error(errorMessage);
-            }
+        else {
+            throw new Error(`Invalid provider configuration: ${provider}`);
         }
-        const response = await httpResponse.json();
-        // Capture the actual model returned by OpenAI (may differ from requested)
-        const actualModel = response.model;
         llmCallFinishedAt = new Date().toISOString();
         llmCallResponseTimeMs = new Date(llmCallFinishedAt).getTime() - new Date(llmCallStartedAt).getTime();
-        // Capture token usage if available
-        if (response.usage) {
-            llmCallTokens = {
-                prompt_tokens: response.usage.prompt_tokens || 0,
-                completion_tokens: response.usage.completion_tokens || 0,
-                total_tokens: response.usage.total_tokens || 0
-            };
-        }
-        const content = response.choices?.[0]?.message?.content;
-        if (!content) {
-            throw new Error('No response from LLM');
-        }
         const parsed = JSON.parse(content);
         logger_1.logger.debug(`   ✅ ${threadline.id}: ${parsed.status}`);
         // Extract file references - rely entirely on LLM to provide them
@@ -193,11 +154,11 @@ async function processThreadline(threadline, diff, files, apiKey, model, service
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
         llmCallErrorMessage = errorMessage;
         // Log full error for debugging
-        logger_1.logger.error(`   ❌ OpenAI error: ${JSON.stringify(error, null, 2)}`);
-        // Extract OpenAI error details from the error object
+        logger_1.logger.error(`   ❌ ${provider.toUpperCase()} error: ${JSON.stringify(error, null, 2)}`);
+        // Extract error details from the error object
         // Handle both SDK-style errors and HTTP errors
         const errorObj = error;
-        const openAIError = errorObj?.error || {};
+        const apiError = errorObj?.error || {};
         const rawErrorResponse = {
             status: errorObj?.status,
             headers: errorObj?.headers,
@@ -221,8 +182,8 @@ async function processThreadline(threadline, diff, files, apiKey, model, service
             reasoning: `Error: ${errorMessage}`,
             error: {
                 message: errorMessage,
-                type: openAIError?.type || errorObj?.type,
-                code: openAIError?.code || errorObj?.code,
+                type: apiError?.type || errorObj?.type,
+                code: apiError?.code || errorObj?.code,
                 rawResponse: rawErrorResponse
             },
             fileReferences: [],
@@ -240,6 +201,288 @@ async function processThreadline(threadline, diff, files, apiKey, model, service
         };
     }
 }
+async function callBedrockAPI(config, prompt) {
+    // Dynamic import - only loads aws4 when Bedrock is configured
+    // aws4 is a required dependency, so it should always be available
+    const aws4Module = await Promise.resolve(`${'aws4'}`).then(s => __importStar(require(s)));
+    const aws4 = aws4Module.default || aws4Module;
+    // Define JSON schema for structured output via Tool Use
+    // This ensures Claude returns properly structured JSON without markdown wrapping
+    const toolSchema = {
+        type: 'object',
+        properties: {
+            status: {
+                type: 'string',
+                enum: ['compliant', 'attention', 'not_relevant'],
+            },
+            reasoning: {
+                type: 'string',
+            },
+            file_references: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                },
+            },
+        },
+        required: ['status', 'reasoning', 'file_references'],
+    };
+    // System message focused on analysis, not JSON format (tool enforces structure)
+    const systemMessage = 'You are a code quality checker. Analyze code changes against the threadline guidelines. Be precise - only flag actual violations.';
+    logger_1.logger.debug(`   🔧 Bedrock: Using Tool Use for structured JSON output`);
+    // Prepare the Converse API request body with Tool Use configuration
+    const body = JSON.stringify({
+        modelId: config.model,
+        system: [
+            {
+                text: systemMessage,
+            },
+        ],
+        messages: [
+            {
+                role: 'user',
+                content: [{ text: prompt }],
+            },
+        ],
+        toolConfig: {
+            tools: [
+                {
+                    toolSpec: {
+                        name: 'return_analysis_result',
+                        description: 'Returns the code quality analysis result as structured JSON',
+                        inputSchema: {
+                            json: toolSchema,
+                        },
+                    },
+                },
+            ],
+        },
+        toolChoice: {
+            type: 'tool',
+            tool: {
+                name: 'return_analysis_result',
+            },
+        },
+        inferenceConfig: {
+            maxTokens: 4000, // Match OpenAI's typical max
+        },
+    });
+    // Prepare request options for aws4 signing
+    // Bedrock Converse API endpoint: POST /model/{modelId}/converse
+    const requestOptions = {
+        hostname: `bedrock-runtime.${config.region}.amazonaws.com`,
+        path: `/model/${config.model}/converse`,
+        method: 'POST',
+        service: 'bedrock',
+        region: config.region,
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: body,
+    };
+    // Sign the request with AWS SigV4
+    aws4.sign(requestOptions, {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+    });
+    // Use AbortController for timeout (higher-level timeout in expert.ts is 40s, use 45s here as safety margin)
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 45000);
+    let httpResponse;
+    try {
+        // Make the HTTP request using native fetch (Node 18+)
+        const url = `https://${requestOptions.hostname}${requestOptions.path}`;
+        httpResponse = await fetch(url, {
+            method: requestOptions.method,
+            headers: requestOptions.headers,
+            body: requestOptions.body,
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+    }
+    catch (fetchError) {
+        clearTimeout(timeoutId);
+        // Handle AbortError from timeout
+        if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+            throw new Error('Request timeout');
+        }
+        throw fetchError;
+    }
+    if (!httpResponse.ok) {
+        const errorText = await httpResponse.text();
+        let errorMessage = `HTTP ${httpResponse.status}: ${errorText}`;
+        // Try to parse Bedrock error structure
+        try {
+            const errorData = JSON.parse(errorText);
+            if (errorData.message) {
+                errorMessage = errorData.message;
+                // Create error object matching SDK error structure for compatibility
+                const errorObj = new Error(errorMessage);
+                errorObj.status = httpResponse.status;
+                errorObj.error = {
+                    type: errorData.__type,
+                };
+                throw errorObj;
+            }
+        }
+        catch (parseError) {
+            // If it's already our structured error, re-throw it
+            const structuredError = parseError;
+            if (structuredError.status) {
+                throw parseError;
+            }
+            // Otherwise create a basic error
+            throw new Error(errorMessage);
+        }
+    }
+    const responseData = await httpResponse.json();
+    logger_1.logger.debug(`   🔧 Bedrock: Parsing Tool Use response`);
+    // Extract structured JSON from Tool Use response
+    // With toolChoice set, Claude should always return a toolUse block
+    let toolUseInput = null;
+    if (responseData.output?.message?.content) {
+        const contentBlocks = responseData.output.message.content;
+        logger_1.logger.debug(`   🔧 Bedrock: Found ${contentBlocks.length} content block(s)`);
+        for (let i = 0; i < contentBlocks.length; i++) {
+            const block = contentBlocks[i];
+            if (block.toolUse) {
+                logger_1.logger.debug(`   🔧 Bedrock: Found toolUse block ${i + 1}: name="${block.toolUse.name}", id="${block.toolUse.id}"`);
+                if (block.toolUse.name !== 'return_analysis_result') {
+                    throw new Error(`Unexpected tool name: ${block.toolUse.name}. Expected: return_analysis_result`);
+                }
+                if (!block.toolUse.input) {
+                    throw new Error(`Tool Use block missing input field. Tool ID: ${block.toolUse.id}`);
+                }
+                toolUseInput = block.toolUse.input;
+                break; // Use first matching toolUse block
+            }
+            else if (block.text) {
+                logger_1.logger.debug(`   🔧 Bedrock: Found text block ${i + 1} (unexpected when toolChoice is set)`);
+            }
+        }
+    }
+    // Hard error if no toolUse block found (shouldn't happen with toolChoice)
+    if (!toolUseInput) {
+        logger_1.logger.error(`   ❌ Bedrock: No toolUse block found in response`);
+        logger_1.logger.error(`   ❌ Bedrock: Response structure: ${JSON.stringify(responseData, null, 2)}`);
+        throw new Error('Bedrock Tool Use failed: No toolUse block found in response. Claude did not use the required tool.');
+    }
+    logger_1.logger.debug(`   🔧 Bedrock: Successfully extracted tool input`);
+    // Convert tool input (already a JSON object) to string for consistency with OpenAI path
+    const content = JSON.stringify(toolUseInput);
+    // Map Bedrock token structure to OpenAI format
+    let tokens = null;
+    if (responseData.usage) {
+        tokens = {
+            prompt_tokens: responseData.usage.inputTokens || 0,
+            completion_tokens: responseData.usage.outputTokens || 0,
+            total_tokens: responseData.usage.totalTokens || 0
+        };
+    }
+    return {
+        model: config.model,
+        content,
+        tokens
+    };
+}
+async function callOpenAIAPI(config, prompt) {
+    // Build request body for OpenAI API (direct HTTP call - zero dependencies)
+    const requestBody = {
+        model: config.model,
+        messages: [
+            {
+                role: 'system',
+                content: 'You are a code quality checker. Analyze code changes against the threadline guidelines. Be precise - only flag actual violations. Return only valid JSON, no other text.'
+            },
+            {
+                role: 'user',
+                content: prompt
+            }
+        ],
+        response_format: { type: 'json_object' },
+        temperature: 0.1
+    };
+    // Add service_tier if not 'standard'
+    const normalizedServiceTier = config.serviceTier.toLowerCase();
+    if (normalizedServiceTier !== 'standard' && (normalizedServiceTier === 'auto' || normalizedServiceTier === 'default' || normalizedServiceTier === 'flex')) {
+        requestBody.service_tier = normalizedServiceTier;
+    }
+    // Direct HTTP call to OpenAI API (native fetch - zero dependencies)
+    // Use AbortController for timeout (higher-level timeout in expert.ts is 40s, use 45s here as safety margin)
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 45000);
+    let httpResponse;
+    try {
+        httpResponse = await fetch('https://api.openai.com/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+    }
+    catch (fetchError) {
+        clearTimeout(timeoutId);
+        // Handle AbortError from timeout
+        if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+            throw new Error('Request timeout');
+        }
+        throw fetchError;
+    }
+    if (!httpResponse.ok) {
+        const errorText = await httpResponse.text();
+        let errorMessage = `HTTP ${httpResponse.status}: ${errorText}`;
+        // Try to parse OpenAI error structure
+        try {
+            const errorData = JSON.parse(errorText);
+            if (errorData.error) {
+                errorMessage = errorData.error.message || errorText;
+                // Create error object matching SDK error structure for compatibility
+                const errorObj = new Error(errorMessage);
+                errorObj.status = httpResponse.status;
+                errorObj.error = {
+                    type: errorData.error.type,
+                    code: errorData.error.code,
+                    param: errorData.error.param,
+                };
+                throw errorObj;
+            }
+        }
+        catch (parseError) {
+            // If it's already our structured error, re-throw it
+            const structuredError = parseError;
+            if (structuredError.status) {
+                throw parseError;
+            }
+            // Otherwise create a basic error
+            throw new Error(errorMessage);
+        }
+    }
+    const response = await httpResponse.json();
+    // Capture the actual model returned by OpenAI (may differ from requested)
+    const actualModel = response.model || config.model;
+    // Capture token usage if available
+    let tokens = null;
+    if (response.usage) {
+        tokens = {
+            prompt_tokens: response.usage.prompt_tokens || 0,
+            completion_tokens: response.usage.completion_tokens || 0,
+            total_tokens: response.usage.total_tokens || 0
+        };
+    }
+    const content = response.choices?.[0]?.message?.content;
+    if (!content) {
+        throw new Error('No response from LLM');
+    }
+    return {
+        model: actualModel,
+        content,
+        tokens
+    };
+}
 function matchesPattern(filePath, pattern) {
     // Convert glob pattern to regex
     // Handle ** first (before single *), escape it to avoid double replacement

package/dist/utils/config.js

@@ -7,12 +7,11 @@ exports.getThreadlineApiKey = getThreadlineApiKey;
 exports.getThreadlineAccount = getThreadlineAccount;
 exports.getOpenAIConfig = getOpenAIConfig;
 exports.logOpenAIConfig = logOpenAIConfig;
+exports.getBedrockConfig = getBedrockConfig;
+exports.logBedrockConfig = logBedrockConfig;
 exports.isDirectModeAvailable = isDirectModeAvailable;
 const chalk_1 = __importDefault(require("chalk"));
 const logger_1 = require("./logger");
-// Default values for OpenAI configuration
-const OPENAI_MODEL_DEFAULT = 'gpt-5.2';
-const OPENAI_SERVICE_TIER_DEFAULT = 'Flex';
 /**
  * Gets THREADLINE_API_KEY from environment.
  *
@@ -49,15 +48,19 @@ function getThreadlineAccount() {
  * Gets OpenAI configuration from environment variables and config file.
  *
  * Required:
- * - OPENAI_API_KEY: Your OpenAI API key (from environment)
- *
- * Model and service tier come from ThreadlineConfig (.threadlinerc file).
- * Falls back to environment variables if not in config, then to defaults.
+ * - OPENAI_API_KEY: Your OpenAI API key (from environment - secret)
+ * - openai_model: Model name (from .threadlinerc - required)
+ * - openai_service_tier: Service tier (from .threadlinerc - required)
  *
  * Returns undefined if OPENAI_API_KEY is not set.
+ * Throws an error if model or service tier are missing from .threadlinerc.
  *
  * Note: .env.local is automatically loaded at CLI startup (see index.ts).
  * In CI/CD, environment variables are injected directly into process.env.
+ *
+ * Configuration philosophy:
+ * - Secrets (API keys) -> environment variables
+ * - Config (model, service tier) -> .threadlinerc file (required, no fallbacks)
  */
 function getOpenAIConfig(config) {
     const apiKey = process.env.OPENAI_API_KEY;
@@ -66,31 +69,21 @@ function getOpenAIConfig(config) {
         return undefined;
     }
     logger_1.logger.debug('OPENAI_API_KEY: found (value hidden for security)');
-    // Priority: config file > environment variable > default
-    const model = config?.openai_model || process.env.OPENAI_MODEL || OPENAI_MODEL_DEFAULT;
-    const serviceTier = config?.openai_service_tier || process.env.OPENAI_SERVICE_TIER || OPENAI_SERVICE_TIER_DEFAULT;
-    if (config?.openai_model) {
-        logger_1.logger.debug(`OPENAI_MODEL: ${model} (from .threadlinerc)`);
-    }
-    else if (process.env.OPENAI_MODEL) {
-        logger_1.logger.debug(`OPENAI_MODEL: ${model} (from environment)`);
-    }
-    else {
-        logger_1.logger.debug(`OPENAI_MODEL: ${model} (using default)`);
-    }
-    if (config?.openai_service_tier) {
-        logger_1.logger.debug(`OPENAI_SERVICE_TIER: ${serviceTier} (from .threadlinerc)`);
-    }
-    else if (process.env.OPENAI_SERVICE_TIER) {
-        logger_1.logger.debug(`OPENAI_SERVICE_TIER: ${serviceTier} (from environment)`);
+    // Require config values from .threadlinerc - no fallbacks
+    if (!config?.openai_model) {
+        throw new Error('Missing required configuration: openai_model must be set in .threadlinerc file.\n' +
+            'Add "openai_model": "gpt-5.2" (or your preferred model) to your .threadlinerc file.');
     }
-    else {
-        logger_1.logger.debug(`OPENAI_SERVICE_TIER: ${serviceTier} (using default)`);
+    if (!config?.openai_service_tier) {
+        throw new Error('Missing required configuration: openai_service_tier must be set in .threadlinerc file.\n' +
+            'Add "openai_service_tier": "Flex" (or your preferred tier) to your .threadlinerc file.');
     }
+    logger_1.logger.debug(`OPENAI_MODEL: ${config.openai_model} (from .threadlinerc)`);
+    logger_1.logger.debug(`OPENAI_SERVICE_TIER: ${config.openai_service_tier} (from .threadlinerc)`);
     return {
         apiKey,
-        model,
-        serviceTier
+        model: config.openai_model,
+        serviceTier: config.openai_service_tier
     };
 }
 /**
@@ -99,8 +92,64 @@ function getOpenAIConfig(config) {
  */
 function logOpenAIConfig(config) {
     logger_1.logger.output(chalk_1.default.blue('OpenAI Direct Mode:'));
-    logger_1.logger.output(chalk_1.default.gray(`  Model: ${config.model}${config.model === OPENAI_MODEL_DEFAULT ? ' (default)' : ''}`));
-    logger_1.logger.output(chalk_1.default.gray(`  Service Tier: ${config.serviceTier}${config.serviceTier === OPENAI_SERVICE_TIER_DEFAULT ? ' (default)' : ''}`));
+    logger_1.logger.output(chalk_1.default.gray(`  Model: ${config.model}`));
+    logger_1.logger.output(chalk_1.default.gray(`  Service Tier: ${config.serviceTier}`));
+    logger_1.logger.output('');
+}
+/**
+ * Gets Bedrock configuration from environment variables and config file.
+ *
+ * Required:
+ * - BEDROCK_ACCESS_KEY_ID: Your AWS access key ID (from environment - secret)
+ * - BEDROCK_SECRET_ACCESS_KEY: Your AWS secret access key (from environment - secret)
+ * - bedrock_model: Model name (from .threadlinerc - required)
+ * - bedrock_region: AWS region (from .threadlinerc - required)
+ *
+ * Returns undefined if BEDROCK_ACCESS_KEY_ID or BEDROCK_SECRET_ACCESS_KEY is not set.
+ * Throws an error if model or region are missing from .threadlinerc.
+ *
+ * Note: .env.local is automatically loaded at CLI startup (see index.ts).
+ * In CI/CD, environment variables are injected directly into process.env.
+ *
+ * Configuration philosophy:
+ * - Secrets (access keys) -> environment variables
+ * - Config (model, region) -> .threadlinerc file (required, no fallbacks)
+ */
+function getBedrockConfig(config) {
+    const accessKeyId = process.env.BEDROCK_ACCESS_KEY_ID;
+    const secretAccessKey = process.env.BEDROCK_SECRET_ACCESS_KEY;
+    if (!accessKeyId || !secretAccessKey) {
+        logger_1.logger.debug('BEDROCK_ACCESS_KEY_ID or BEDROCK_SECRET_ACCESS_KEY: not set (Bedrock mode unavailable)');
+        return undefined;
+    }
+    logger_1.logger.debug('BEDROCK_ACCESS_KEY_ID: found (value hidden for security)');
+    logger_1.logger.debug('BEDROCK_SECRET_ACCESS_KEY: found (value hidden for security)');
+    // Require config values from .threadlinerc - no fallbacks
+    if (!config?.bedrock_model) {
+        throw new Error('Missing required configuration: bedrock_model must be set in .threadlinerc file.\n' +
+            'Add "bedrock_model": "us.anthropic.claude-sonnet-4-5-20250929-v1:0" (or your preferred model) to your .threadlinerc file.');
+    }
+    if (!config?.bedrock_region) {
+        throw new Error('Missing required configuration: bedrock_region must be set in .threadlinerc file.\n' +
+            'Add "bedrock_region": "us-east-1" (or your preferred AWS region) to your .threadlinerc file.');
+    }
+    logger_1.logger.debug(`BEDROCK_MODEL: ${config.bedrock_model} (from .threadlinerc)`);
+    logger_1.logger.debug(`BEDROCK_REGION: ${config.bedrock_region} (from .threadlinerc)`);
+    return {
+        accessKeyId,
+        secretAccessKey,
+        model: config.bedrock_model,
+        region: config.bedrock_region
+    };
+}
+/**
+ * Logs the Bedrock configuration being used.
+ * Call this when starting Bedrock mode to inform the user.
+ */
+function logBedrockConfig(config) {
+    logger_1.logger.output(chalk_1.default.blue('Amazon Bedrock Direct Mode:'));
+    logger_1.logger.output(chalk_1.default.gray(`  Model: ${config.model}`));
+    logger_1.logger.output(chalk_1.default.gray(`  Region: ${config.region}`));
     logger_1.logger.output('');
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadlines",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Threadlines CLI - AI-powered linter based on your natural language documentation",
   "main": "dist/index.js",
   "bin": {
@@ -48,6 +48,7 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
+    "aws4": "^1.13.2",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
     "dotenv": "^16.4.7",
@@ -55,6 +56,7 @@
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
+    "@types/aws4": "^1.11.4",
     "@types/glob": "^8.1.0",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.10.2",