threadlines 0.2.6 → 0.2.9

package/dist/api/client.js

@@ -16,23 +16,8 @@ class ReviewAPIClient {
         });
     }
     async review(request) {
-        try {
-            const response = await this.client.post('/api/threadline-check', request);
-            return response.data;
-        }
-        catch (error) {
-            if (error && typeof error === 'object' && 'response' in error) {
-                const axiosError = error;
-                throw new Error(`API error: ${axiosError.response.status} - ${axiosError.response.data?.message || axiosError.message || 'Unknown error'}`);
-            }
-            else if (error && typeof error === 'object' && 'request' in error) {
-                throw new Error(`Network error: Could not reach Threadline server at ${this.client.defaults.baseURL}`);
-            }
-            else {
-                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                throw new Error(`Request error: ${errorMessage}`);
-            }
-        }
+        const response = await this.client.post('/api/threadline-check', request);
+        return response.data;
     }
 }
 exports.ReviewAPIClient = ReviewAPIClient;

package/dist/commands/check.js

@@ -48,6 +48,8 @@ const bitbucket_1 = require("../git/bitbucket");
 const vercel_1 = require("../git/vercel");
 const local_1 = require("../git/local");
 const diff_1 = require("../git/diff");
+const config_file_1 = require("../utils/config-file");
+const logger_1 = require("../utils/logger");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
@@ -77,6 +79,8 @@ const CLI_VERSION = packageJson.version;
 async function checkCommand(options) {
     const cwd = process.cwd();
     const repoRoot = cwd; // Keep for backward compatibility with rest of function
+    // Load configuration
+    const config = await (0, config_file_1.loadConfig)(cwd);
     console.log(chalk_1.default.blue(`🔍 Threadline CLI v${CLI_VERSION}: Checking code against your threadlines...\n`));
     // Get git root for consistent file paths across monorepo
     const git = (0, simple_git_1.default)(cwd);
@@ -84,13 +88,13 @@ async function checkCommand(options) {
     try {
         const isRepo = await git.checkIsRepo();
         if (!isRepo) {
-            console.error(chalk_1.default.red('❌ Error: Not a git repository. Threadline requires a git repository.'));
+            logger_1.logger.error('Not a git repository. Threadline requires a git repository.');
             process.exit(1);
         }
         gitRoot = (await git.revparse(['--show-toplevel'])).trim();
     }
     catch {
-        console.error(chalk_1.default.red('❌ Error: Failed to get git root. Make sure you are in a git repository.'));
+        logger_1.logger.error('Failed to get git root. Make sure you are in a git repository.');
         process.exit(1);
     }
     // Pre-flight check: Validate ALL required environment variables at once
@@ -103,9 +107,9 @@ async function checkCommand(options) {
     if (!account || account.startsWith('$'))
         missingVars.push('THREADLINE_ACCOUNT');
     if (missingVars.length > 0) {
-        console.error(chalk_1.default.red('❌ Error: Missing required environment variables:'));
+        logger_1.logger.error('Missing required environment variables:');
         for (const varName of missingVars) {
-            console.error(chalk_1.default.red(`   • ${varName}`));
+            logger_1.logger.error(`   • ${varName}`);
         }
         console.log('');
         console.log(chalk_1.default.yellow('To fix this:'));
@@ -132,7 +136,7 @@ async function checkCommand(options) {
     }
     try {
         // 1. Find and validate threadlines
-        console.log(chalk_1.default.gray('📋 Finding threadlines...'));
+        logger_1.logger.info('Finding threadlines...');
         const threadlines = await (0, experts_1.findThreadlines)(cwd, gitRoot);
         console.log(chalk_1.default.green(`✓ Found ${threadlines.length} threadline(s)\n`));
         if (threadlines.length === 0) {
@@ -147,11 +151,11 @@ async function checkCommand(options) {
         let branchName;
         let metadata = {};
         // Check for explicit flags
-        const explicitFlags = [options.branch, options.commit, options.file, options.folder, options.files].filter(Boolean);
+        const explicitFlags = [options.commit, options.file, options.folder, options.files].filter(Boolean);
         // Validate mutually exclusive flags
         if (explicitFlags.length > 1) {
-            console.error(chalk_1.default.red('❌ Error: Only one review option can be specified at a time'));
-            console.log(chalk_1.default.gray('   Options: --branch, --commit, --file, --folder, --files'));
+            logger_1.logger.error('Only one review option can be specified at a time');
+            console.log(chalk_1.default.gray('   Options: --commit, --file, --folder, --files'));
             process.exit(1);
         }
         // CI environments: auto-detect only, flags are ignored with warning
@@ -159,11 +163,10 @@ async function checkCommand(options) {
         if ((0, environment_1.isCIEnvironment)(environment)) {
             // Warn if flags are passed in CI - they're meant for local development
             if (explicitFlags.length > 0) {
-                const flagName = options.branch ? '--branch' :
-                    options.commit ? '--commit' :
-                        options.file ? '--file' :
-                            options.folder ? '--folder' : '--files';
-                console.log(chalk_1.default.yellow(`⚠️  Warning: ${flagName} flag ignored in CI environment. Using auto-detection.\n`));
+                const flagName = options.commit ? '--commit' :
+                    options.file ? '--file' :
+                        options.folder ? '--folder' : '--files';
+                logger_1.logger.warn(`${flagName} flag ignored in CI environment. Using auto-detection.`);
             }
             // CI auto-detect: use environment-specific context
             const envNames = {
@@ -172,7 +175,7 @@ async function checkCommand(options) {
                 gitlab: 'GitLab CI',
                 bitbucket: 'Bitbucket Pipelines'
             };
-            console.log(chalk_1.default.gray(`📝 Collecting git context for ${envNames[environment]}...`));
+            logger_1.logger.info(`Collecting git context for ${envNames[environment]}...`);
             const envContext = await getContextForEnvironment(environment, repoRoot);
             gitDiff = envContext.diff;
             repoName = envContext.repoName;
@@ -188,33 +191,19 @@ async function checkCommand(options) {
         else {
             // Local environment: support all flags
             if (options.file) {
-                console.log(chalk_1.default.gray(`📝 Reading file: ${options.file}...`));
+                logger_1.logger.info(`Reading file: ${options.file}...`);
                 gitDiff = await (0, file_1.getFileContent)(repoRoot, options.file);
             }
             else if (options.folder) {
-                console.log(chalk_1.default.gray(`📝 Reading folder: ${options.folder}...`));
+                logger_1.logger.info(`Reading folder: ${options.folder}...`);
                 gitDiff = await (0, file_1.getFolderContent)(repoRoot, options.folder);
             }
             else if (options.files && options.files.length > 0) {
-                console.log(chalk_1.default.gray(`📝 Reading ${options.files.length} file(s)...`));
+                logger_1.logger.info(`Reading ${options.files.length} file(s)...`);
                 gitDiff = await (0, file_1.getMultipleFilesContent)(repoRoot, options.files);
             }
-            else if (options.branch) {
-                console.log(chalk_1.default.gray(`📝 Collecting git changes for branch: ${options.branch}...`));
-                gitDiff = await (0, diff_1.getBranchDiff)(repoRoot, options.branch);
-                // Use local context for metadata
-                const localContext = await (0, local_1.getLocalContext)(repoRoot);
-                repoName = localContext.repoName;
-                branchName = localContext.branchName;
-                metadata = {
-                    commitSha: localContext.commitSha,
-                    commitMessage: localContext.commitMessage,
-                    commitAuthorName: localContext.commitAuthor.name,
-                    commitAuthorEmail: localContext.commitAuthor.email
-                };
-            }
             else if (options.commit) {
-                console.log(chalk_1.default.gray(`📝 Collecting git changes for commit: ${options.commit}...`));
+                logger_1.logger.info(`Collecting git changes for commit: ${options.commit}...`);
                 gitDiff = await (0, diff_1.getCommitDiff)(repoRoot, options.commit);
                 // Use local context for metadata, passing commit SHA for author lookup
                 const localContext = await (0, local_1.getLocalContext)(repoRoot, options.commit);
@@ -229,7 +218,7 @@ async function checkCommand(options) {
             }
             else {
                 // Local auto-detect: staged/unstaged changes
-                console.log(chalk_1.default.gray('📝 Collecting git context for Local...'));
+                logger_1.logger.info('Collecting git context for Local...');
                 const localContext = await (0, local_1.getLocalContext)(repoRoot);
                 gitDiff = localContext.diff;
                 repoName = localContext.repoName;
@@ -279,13 +268,9 @@ async function checkCommand(options) {
                 contextContent
             };
         });
-        // 5. Get API URL
-        const apiUrl = options.apiUrl ||
-            process.env.THREADLINE_API_URL ||
-            'https://devthreadline.com';
-        // 6. Call review API
-        console.log(chalk_1.default.gray('🤖 Running threadline checks...'));
-        const client = new client_1.ReviewAPIClient(apiUrl);
+        // 5. Call review API
+        logger_1.logger.info('Running threadline checks...');
+        const client = new client_1.ReviewAPIClient(config.api_url);
         const response = await client.review({
             threadlines: threadlinesWithContext,
             diff: gitDiff.diff,
@@ -310,7 +295,7 @@ async function checkCommand(options) {
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        console.error(chalk_1.default.red(`\n❌ Error: ${errorMessage}`));
+        logger_1.logger.error(errorMessage);
         process.exit(1);
     }
 }

package/dist/commands/init.js

@@ -40,6 +40,8 @@ exports.initCommand = initCommand;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("../utils/logger");
+const config_file_1 = require("../utils/config-file");
 const TEMPLATE = `---
 id: example-threadline
 version: 1.0.0
@@ -75,12 +77,19 @@ async function initCommand() {
     const repoRoot = process.cwd();
     const threadlinesDir = path.join(repoRoot, 'threadlines');
     const exampleFile = path.join(threadlinesDir, 'example.md');
+    const configFile = path.join(repoRoot, '.threadlinerc');
     try {
         // Create threadlines directory if it doesn't exist
         if (!fs.existsSync(threadlinesDir)) {
             fs.mkdirSync(threadlinesDir, { recursive: true });
             console.log(chalk_1.default.green(`✓ Created /threadlines directory`));
         }
+        // Create .threadlinerc if it doesn't exist
+        if (!fs.existsSync(configFile)) {
+            const configContent = JSON.stringify(config_file_1.DEFAULT_CONFIG, null, 2);
+            fs.writeFileSync(configFile, configContent, 'utf-8');
+            console.log(chalk_1.default.green(`✓ Created .threadlinerc`));
+        }
         // Check if example file already exists
         if (fs.existsSync(exampleFile)) {
             console.log(chalk_1.default.yellow(`⚠️  ${exampleFile} already exists`));
@@ -109,7 +118,7 @@ async function initCommand() {
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        console.error(chalk_1.default.red(`\n❌ Error: ${errorMessage}`));
+        logger_1.logger.error(errorMessage);
         process.exit(1);
     }
 }

package/dist/git/bitbucket.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Bitbucket Pipelines Environment - Complete Isolation
+ * Bitbucket Pipelines Environment
  *
  * All Bitbucket-specific logic is contained in this file.
  * No dependencies on other environment implementations.
@@ -25,6 +25,7 @@ exports.getBitbucketContext = getBitbucketContext;
 const simple_git_1 = __importDefault(require("simple-git"));
 const child_process_1 = require("child_process");
 const diff_1 = require("./diff");
+const logger_1 = require("../utils/logger");
 /**
  * Gets all Bitbucket context in one call
  */
@@ -65,105 +66,38 @@ async function getBitbucketContext(repoRoot) {
 /**
  * Get diff for Bitbucket Pipelines environment
  *
- * Bitbucket Pipelines with depth: full has full git history available,
- * including origin/main. Unlike GitLab, no fetch is needed.
+ * Strategy:
+ * - PR context: Fetch destination branch on-demand, compare source vs target (full PR diff)
+ * - Any push (main or feature branch): Compare last commit only (HEAD~1...HEAD)
  *
- * Diff Strategy:
- *
- * | Scenario                  | Target Branch Known?                        | Diff Command                              |
- * |---------------------------|---------------------------------------------|-------------------------------------------|
- * | PR                        | ✅ Yes - BITBUCKET_PR_DESTINATION_BRANCH    | origin/${destination}...HEAD              |
- * | Feature branch (no PR)    | ❌ No - detect main/master                  | origin/main...HEAD or origin/master...HEAD|
- * | Push to default branch    | N/A                                         | HEAD~1...HEAD                             |
- *
- * Key point: For PRs, Bitbucket provides BITBUCKET_PR_DESTINATION_BRANCH - this is the
- * most relevant comparison point because it's where the code will be merged.
- *
- * For non-PR feature branches, Bitbucket does NOT provide a default branch env var
- * (unlike GitLab's CI_DEFAULT_BRANCH), so we detect by checking if origin/main or
- * origin/master exists.
+ * Note: We fetch the destination branch on-demand so this works with shallow clones.
+ * Users don't need `depth: full` in their bitbucket-pipelines.yml.
  */
 async function getDiff(repoRoot) {
     const git = (0, simple_git_1.default)(repoRoot);
-    const branchName = process.env.BITBUCKET_BRANCH;
     const prId = process.env.BITBUCKET_PR_ID;
     const prDestinationBranch = process.env.BITBUCKET_PR_DESTINATION_BRANCH;
-    // Scenario 1: PR context - use the target branch from env var
+    // PR Context: Fetch destination branch and compare
     if (prId) {
         if (!prDestinationBranch) {
             throw new Error('Bitbucket PR context detected but BITBUCKET_PR_DESTINATION_BRANCH is not set. ' +
                 'This should be automatically provided by Bitbucket Pipelines.');
         }
-        console.log(`  [Bitbucket] PR #${prId}, using origin/${prDestinationBranch}...HEAD`);
+        // Fetch destination branch on-demand (works with shallow clones)
+        logger_1.logger.debug(`Fetching destination branch: origin/${prDestinationBranch}`);
+        await git.fetch(['origin', `${prDestinationBranch}:refs/remotes/origin/${prDestinationBranch}`, '--depth=1']);
+        logger_1.logger.debug(`PR #${prId}, using origin/${prDestinationBranch}...HEAD`);
         const diff = await git.diff([`origin/${prDestinationBranch}...HEAD`, '-U200']);
         const diffSummary = await git.diffSummary([`origin/${prDestinationBranch}...HEAD`]);
         const changedFiles = diffSummary.files.map(f => f.file);
         return { diff: diff || '', changedFiles };
     }
-    // Scenario 2: Non-PR push
-    if (!branchName) {
-        throw new Error('Bitbucket Pipelines: BITBUCKET_BRANCH environment variable is not set. ' +
-            'This should be automatically provided by Bitbucket Pipelines.');
-    }
-    // Detect the default branch (Bitbucket doesn't provide this as an env var)
-    const defaultBranch = await detectDefaultBranch(git);
-    // If we're on the default branch, just show the last commit
-    if (branchName === defaultBranch) {
-        console.log(`  [Bitbucket] Push to ${defaultBranch}, using HEAD~1...HEAD`);
-        const diff = await git.diff(['HEAD~1...HEAD', '-U200']);
-        const diffSummary = await git.diffSummary(['HEAD~1...HEAD']);
-        const changedFiles = diffSummary.files.map(f => f.file);
-        return { diff: diff || '', changedFiles };
-    }
-    // Feature branch: compare against default branch
-    // This shows all changes the branch introduces, correctly excluding
-    // any commits merged in from the default branch
-    console.log(`  [Bitbucket] Feature branch "${branchName}", using origin/${defaultBranch}...HEAD`);
-    const diff = await git.diff([`origin/${defaultBranch}...HEAD`, '-U200']);
-    const diffSummary = await git.diffSummary([`origin/${defaultBranch}...HEAD`]);
+    // Any push (main or feature branch): Review last commit only
+    const diff = await git.diff(['HEAD~1...HEAD', '-U200']);
+    const diffSummary = await git.diffSummary(['HEAD~1...HEAD']);
     const changedFiles = diffSummary.files.map(f => f.file);
     return { diff: diff || '', changedFiles };
 }
-/**
- * Detect the default branch for Bitbucket Pipelines.
- *
- * Bitbucket does NOT provide a default branch env var (unlike GitLab's CI_DEFAULT_BRANCH
- * or GitHub's repository.default_branch in the event JSON).
- *
- * We try 'main' first (most common), then 'master' as fallback.
- * This covers the vast majority of repositories.
- *
- * ---
- * Design Decision: We compare against main instead of just checking the last commit
- *
- * Threadlines assumes that feature branches are intended to eventually merge to the
- * default branch. Comparing against main shows ALL changes the branch introduces,
- * which is what you want to review before merging.
- *
- * Per-commit checking happens during local development.
- * ---
- */
-async function detectDefaultBranch(git) {
-    // Try 'main' first (modern default)
-    try {
-        await git.revparse(['--verify', 'origin/main']);
-        return 'main';
-    }
-    catch {
-        // origin/main doesn't exist, try master
-    }
-    // Try 'master' (legacy default)
-    try {
-        await git.revparse(['--verify', 'origin/master']);
-        return 'master';
-    }
-    catch {
-        // origin/master doesn't exist either
-    }
-    throw new Error('Bitbucket Pipelines: Cannot determine default branch. ' +
-        'Neither origin/main nor origin/master found. ' +
-        'For repositories with a different default branch, create a PR to trigger branch comparison.');
-}
 /**
  * Gets repository name for Bitbucket Pipelines
  *
@@ -190,7 +124,10 @@ function getBranchName() {
     return branchName;
 }
 /**
- * Detects Bitbucket context (PR, branch, or commit)
+ * Detects Bitbucket context (PR or commit)
+ *
+ * - PR context: When BITBUCKET_PR_ID is set
+ * - Commit context: Any push (main or feature branch) - reviews single commit
  */
 function detectContext() {
     // PR context
@@ -205,22 +142,16 @@ function detectContext() {
             targetBranch: prDestinationBranch
         };
     }
-    // Branch context
-    if (process.env.BITBUCKET_BRANCH) {
-        return {
-            type: 'branch',
-            branchName: process.env.BITBUCKET_BRANCH
-        };
-    }
-    // Commit context
+    // Any push (main or feature branch) → commit context
     if (process.env.BITBUCKET_COMMIT) {
         return {
             type: 'commit',
             commitSha: process.env.BITBUCKET_COMMIT
         };
     }
-    // Fallback to local (shouldn't happen in Bitbucket Pipelines)
-    return { type: 'local' };
+    throw new Error('Bitbucket Pipelines: Could not detect context. ' +
+        'Expected BITBUCKET_PR_ID or BITBUCKET_COMMIT to be set. ' +
+        'This should be automatically provided by Bitbucket Pipelines.');
 }
 /**
  * Gets commit SHA from Bitbucket environment

package/dist/git/diff.js

@@ -3,185 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBranchDiff = getBranchDiff;
 exports.getCommitMessage = getCommitMessage;
 exports.getCommitAuthor = getCommitAuthor;
 exports.getCommitDiff = getCommitDiff;
-exports.getPRMRDiff = getPRMRDiff;
 const simple_git_1 = __importDefault(require("simple-git"));
-/**
- * Get diff for a specific branch (all commits vs base branch)
- * Uses git merge-base to find common ancestor, then diffs from there
- */
-async function getBranchDiff(repoRoot, branchName, baseBranch) {
-    const git = (0, simple_git_1.default)(repoRoot);
-    // Check if we're in a git repo
-    const isRepo = await git.checkIsRepo();
-    if (!isRepo) {
-        throw new Error('Not a git repository. Threadline requires a git repository.');
-    }
-    // Determine base branch
-    let base;
-    if (baseBranch) {
-        // Use provided base branch
-        base = baseBranch;
-    }
-    else {
-        // Check if the branch itself is a base branch (main/master)
-        const baseBranchNames = ['main', 'master'];
-        const isBaseBranch = baseBranchNames.includes(branchName.toLowerCase());
-        if (isBaseBranch) {
-            // For main/master branch, compare against previous commit (HEAD~1)
-            // This checks what changed in the most recent commit
-            try {
-                const previousCommit = await git.revparse(['HEAD~1']);
-                // Use commit-based diff instead
-                const diff = await git.diff([`${previousCommit}..HEAD`, '-U200']);
-                const diffSummary = await git.diffSummary([`${previousCommit}..HEAD`]);
-                const changedFiles = diffSummary.files.map(f => f.file);
-                return {
-                    diff: diff || '',
-                    changedFiles
-                };
-            }
-            catch (error) {
-                // If no previous commit, return empty (first commit)
-                const errorMessage = error instanceof Error ? error.message : 'HEAD~1 does not exist';
-                console.log(`[DEBUG] No previous commit found (first commit or error): ${errorMessage}`);
-                return {
-                    diff: '',
-                    changedFiles: []
-                };
-            }
-        }
-        // Try to detect base branch: upstream, default branch, or common names
-        base = await detectBaseBranch(git, branchName);
-    }
-    // Helper function to detect base branch
-    // Returns the branch name to use in git commands (may be local or remote)
-    // In CI environments, prioritizes remote refs since local branches often don't exist
-    // Note: Vercel is excluded here because it uses commit context, not branch context
-    async function detectBaseBranch(git, branchName) {
-        const isCI = !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI);
-        // Strategy 1: Try upstream tracking branch (most reliable if set)
-        try {
-            const upstream = await git.revparse(['--abbrev-ref', '--symbolic-full-name', `${branchName}@{u}`]);
-            const upstreamBranch = upstream.replace(/^origin\//, '');
-            // Don't use the branch itself as its base
-            if (upstreamBranch !== branchName) {
-                // In CI, prefer remote refs since local branches often don't exist
-                if (isCI) {
-                    console.log(`[DEBUG] CI environment detected, using upstream tracking branch (remote): ${upstream}`);
-                    return upstream;
-                }
-                // In local dev, check if local branch exists
-                try {
-                    await git.revparse([upstreamBranch]);
-                    console.log(`[DEBUG] Using upstream tracking branch (local): ${upstreamBranch}`);
-                    return upstreamBranch;
-                }
-                catch {
-                    console.log(`[DEBUG] Upstream tracking branch exists but local branch '${upstreamBranch}' not found, using remote: ${upstream}`);
-                    return upstream;
-                }
-            }
-            else {
-                console.log(`[DEBUG] Upstream tracking branch '${upstreamBranch}' is the same as current branch, skipping`);
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'no upstream configured';
-            console.log(`[DEBUG] Upstream tracking branch not set for '${branchName}': ${errorMessage}`);
-        }
-        // Strategy 2: Try default branch from origin/HEAD (reliable if configured)
-        try {
-            const defaultBranch = await git.revparse(['--abbrev-ref', 'refs/remotes/origin/HEAD']);
-            const defaultBranchName = defaultBranch.replace(/^origin\//, '');
-            // Don't use the branch itself as its base
-            if (defaultBranchName !== branchName) {
-                // In CI, prefer remote refs
-                if (isCI) {
-                    console.log(`[DEBUG] CI environment detected, using default branch (remote): ${defaultBranch}`);
-                    return defaultBranch;
-                }
-                // In local dev, check if local branch exists
-                try {
-                    await git.revparse([defaultBranchName]);
-                    console.log(`[DEBUG] Using default branch (local): ${defaultBranchName}`);
-                    return defaultBranchName;
-                }
-                catch {
-                    console.log(`[DEBUG] Default branch exists but local branch '${defaultBranchName}' not found, using remote: ${defaultBranch}`);
-                    return defaultBranch;
-                }
-            }
-            else {
-                console.log(`[DEBUG] Default branch '${defaultBranchName}' is the same as current branch, skipping`);
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'not found';
-            console.log(`[DEBUG] Default branch (refs/remotes/origin/HEAD) not configured: ${errorMessage}`);
-        }
-        // Strategy 3: Try common branch names by checking remote refs first, then local branches
-        // This works reliably in CI with fetch-depth: 0, and also works locally
-        const commonBases = ['main', 'master', 'develop'];
-        for (const candidate of commonBases) {
-            if (candidate.toLowerCase() === branchName.toLowerCase()) {
-                continue; // Skip if it's the same branch
-            }
-            // Try remote ref first
-            try {
-                await git.revparse([`origin/${candidate}`]);
-                // In CI, prefer remote refs since local branches often don't exist
-                if (isCI) {
-                    console.log(`[DEBUG] CI environment detected, using common branch name (remote): origin/${candidate}`);
-                    return `origin/${candidate}`;
-                }
-                // In local dev, check if local branch exists
-                try {
-                    await git.revparse([candidate]);
-                    console.log(`[DEBUG] Using common branch name (local): ${candidate}`);
-                    return candidate;
-                }
-                catch {
-                    console.log(`[DEBUG] Common branch '${candidate}' exists remotely but not locally, using remote: origin/${candidate}`);
-                    return `origin/${candidate}`;
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : 'does not exist';
-                console.log(`[DEBUG] Remote branch 'origin/${candidate}' not found: ${errorMessage}`);
-                // If remote doesn't exist, also try local branch (especially for CI like Vercel)
-                try {
-                    await git.revparse([candidate]);
-                    console.log(`[DEBUG] Remote 'origin/${candidate}' not available, but local branch '${candidate}' found - using local`);
-                    return candidate;
-                }
-                catch (localError) {
-                    const localErrorMessage = localError instanceof Error ? localError.message : 'does not exist';
-                    console.log(`[DEBUG] Local branch '${candidate}' also not found: ${localErrorMessage}`);
-                    // Continue to next candidate
-                }
-            }
-        }
-        // All strategies failed - provide clear error with context
-        throw new Error(`Could not determine base branch for '${branchName}'. ` +
-            `Tried: upstream tracking, default branch (origin/HEAD), and common names (main, master, develop). ` +
-            `Please specify base branch with --base flag or configure upstream tracking with: ` +
-            `git branch --set-upstream-to=origin/main ${branchName}`);
-    }
-    // Get diff between base and branch (cumulative diff of all commits)
-    // Format: git diff base...branch (three-dot notation finds common ancestor)
-    const diff = await git.diff([`${base}...${branchName}`, '-U200']);
-    // Get list of changed files
-    const diffSummary = await git.diffSummary([`${base}...${branchName}`]);
-    const changedFiles = diffSummary.files.map(f => f.file);
-    return {
-        diff: diff || '',
-        changedFiles
-    };
-}
 /**
  * Get commit message for a specific commit SHA
  * Returns full commit message (subject + body) or null if commit not found
@@ -273,24 +98,3 @@ async function getCommitDiff(repoRoot, sha) {
         changedFiles
     };
 }
-/**
- * Get diff for PR/MR (source branch vs target branch)
- */
-async function getPRMRDiff(repoRoot, sourceBranch, targetBranch) {
-    const git = (0, simple_git_1.default)(repoRoot);
-    // Check if we're in a git repo
-    const isRepo = await git.checkIsRepo();
-    if (!isRepo) {
-        throw new Error('Not a git repository. Threadline requires a git repository.');
-    }
-    // Get diff between target and source (cumulative diff)
-    // Format: git diff target...source (three-dot notation finds common ancestor)
-    const diff = await git.diff([`${targetBranch}...${sourceBranch}`, '-U200']);
-    // Get list of changed files
-    const diffSummary = await git.diffSummary([`${targetBranch}...${sourceBranch}`]);
-    const changedFiles = diffSummary.files.map(f => f.file);
-    return {
-        diff: diff || '',
-        changedFiles
-    };
-}

package/dist/git/file.js

@@ -39,6 +39,7 @@ exports.getMultipleFilesContent = getMultipleFilesContent;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const glob_1 = require("glob");
+const logger_1 = require("../utils/logger");
 /**
  * Read content of a single file and create artificial diff (all lines as additions)
  */
@@ -116,7 +117,7 @@ async function getFolderContent(repoRoot, folderPath) {
         catch (error) {
             // Skip files that can't be read (permissions, etc.)
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            console.warn(`Warning: Could not read file '${filePath}': ${errorMessage}`);
+            logger_1.logger.warn(`Could not read file '${filePath}': ${errorMessage}`);
         }
     }
     return {