threadlines 0.1.17 → 0.1.18

package/dist/commands/check.js

@@ -38,38 +38,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkCommand = checkCommand;
 const experts_1 = require("../validators/experts");
-const diff_1 = require("../git/diff");
 const file_1 = require("../git/file");
 const repo_1 = require("../git/repo");
-const ci_detection_1 = require("../utils/ci-detection");
 const client_1 = require("../api/client");
 const config_1 = require("../utils/config");
+const environment_1 = require("../utils/environment");
+const context_1 = require("../utils/context");
+const metadata_1 = require("../utils/metadata");
+const git_diff_executor_1 = require("../utils/git-diff-executor");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
-/**
- * Detect the environment where the check is being run.
- *
- * CI Environment Detection:
- * - Vercel: VERCEL=1
- * - GitHub Actions: GITHUB_ACTIONS=1
- * - GitLab CI: GITLAB_CI=1 or (CI=1 + CI_COMMIT_SHA)
- * - Local: None of the above
- *
- * Available CI Environment Variables:
- * - GitHub Actions: GITHUB_REPOSITORY, GITHUB_REF_NAME, GITHUB_SHA, GITHUB_BASE_REF, GITHUB_HEAD_REF
- * - Vercel: VERCEL_GIT_REPO_OWNER, VERCEL_GIT_REPO_SLUG, VERCEL_GIT_COMMIT_REF, VERCEL_GIT_COMMIT_SHA
- * - GitLab CI: CI_COMMIT_REF_NAME, CI_COMMIT_SHA, CI_MERGE_REQUEST_IID, CI_MERGE_REQUEST_TITLE
- */
-function detectEnvironment() {
-    if (process.env.VERCEL)
-        return 'vercel';
-    if (process.env.GITHUB_ACTIONS)
-        return 'github';
-    if (process.env.GITLAB_CI || (process.env.CI && process.env.CI_COMMIT_SHA))
-        return 'gitlab';
-    return 'local';
-}
 async function checkCommand(options) {
     const repoRoot = process.cwd();
     console.log(chalk_1.default.blue('🔍 Threadline: Checking code against your threadlines...\n'));
@@ -109,12 +88,10 @@ async function checkCommand(options) {
             console.log(chalk_1.default.gray('   Run `npx threadlines init` to create your first threadline.'));
             process.exit(0);
         }
-        // 2. Determine review target and get git diff
+        // 2. Detect environment and context
+        const environment = (0, environment_1.detectEnvironment)();
+        let context;
         let gitDiff;
-        let reviewContext = { type: 'local' };
-        let commitSha = undefined;
-        let commitMessage = undefined;
-        let prTitle = undefined;
         // Validate mutually exclusive flags
         const explicitFlags = [options.branch, options.commit, options.file, options.folder, options.files].filter(Boolean);
         if (explicitFlags.length > 1) {
@@ -126,91 +103,37 @@ async function checkCommand(options) {
         if (options.file) {
             console.log(chalk_1.default.gray(`📝 Reading file: ${options.file}...`));
             gitDiff = await (0, file_1.getFileContent)(repoRoot, options.file);
-            reviewContext = { type: 'file', value: options.file };
+            context = { type: 'local' }; // File context doesn't need git context
         }
         else if (options.folder) {
             console.log(chalk_1.default.gray(`📝 Reading folder: ${options.folder}...`));
             gitDiff = await (0, file_1.getFolderContent)(repoRoot, options.folder);
-            reviewContext = { type: 'folder', value: options.folder };
+            context = { type: 'local' };
         }
         else if (options.files && options.files.length > 0) {
             console.log(chalk_1.default.gray(`📝 Reading ${options.files.length} file(s)...`));
             gitDiff = await (0, file_1.getMultipleFilesContent)(repoRoot, options.files);
-            reviewContext = { type: 'files', value: options.files.join(', ') };
+            context = { type: 'local' };
         }
         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);
-            reviewContext = { type: 'branch', value: options.branch };
+            context = { type: 'branch', branchName: options.branch };
+            gitDiff = await (0, git_diff_executor_1.getDiffForContext)(context, repoRoot, environment);
         }
         else if (options.commit) {
             console.log(chalk_1.default.gray(`📝 Collecting git changes for commit: ${options.commit}...`));
-            gitDiff = await (0, diff_1.getCommitDiff)(repoRoot, options.commit);
-            reviewContext = { type: 'commit', value: options.commit };
-            commitSha = options.commit;
-            // Fetch commit message (reliable when we have SHA)
-            const message = await (0, diff_1.getCommitMessage)(repoRoot, options.commit);
-            if (message) {
-                commitMessage = message;
-            }
+            context = { type: 'commit', commitSha: options.commit };
+            gitDiff = await (0, git_diff_executor_1.getDiffForContext)(context, repoRoot, environment);
         }
         else {
-            // Auto-detect CI environment or use local changes
-            const autoTarget = (0, ci_detection_1.getAutoReviewTarget)();
-            if (autoTarget) {
-                if (autoTarget.type === 'pr' || autoTarget.type === 'mr') {
-                    // PR/MR: use source and target branches
-                    console.log(chalk_1.default.gray(`📝 Collecting git changes for ${autoTarget.type.toUpperCase()}: ${autoTarget.value}...`));
-                    gitDiff = await (0, diff_1.getPRMRDiff)(repoRoot, autoTarget.sourceBranch, autoTarget.targetBranch);
-                    reviewContext = { type: autoTarget.type, value: autoTarget.value };
-                    // Use PR title from GitLab CI (reliable env var)
-                    if (autoTarget.prTitle) {
-                        prTitle = autoTarget.prTitle;
-                    }
-                }
-                else if (autoTarget.type === 'branch') {
-                    // Branch: use branch vs base
-                    console.log(chalk_1.default.gray(`📝 Collecting git changes for branch: ${autoTarget.value}...`));
-                    gitDiff = await (0, diff_1.getBranchDiff)(repoRoot, autoTarget.value);
-                    reviewContext = { type: 'branch', value: autoTarget.value };
-                    // Capture commit SHA from CI env vars if available
-                    if (process.env.GITHUB_SHA) {
-                        commitSha = process.env.GITHUB_SHA;
-                        const message = await (0, diff_1.getCommitMessage)(repoRoot, process.env.GITHUB_SHA);
-                        if (message)
-                            commitMessage = message;
-                    }
-                    else if (process.env.VERCEL_GIT_COMMIT_SHA) {
-                        commitSha = process.env.VERCEL_GIT_COMMIT_SHA;
-                        const message = await (0, diff_1.getCommitMessage)(repoRoot, process.env.VERCEL_GIT_COMMIT_SHA);
-                        if (message)
-                            commitMessage = message;
-                    }
-                }
-                else if (autoTarget.type === 'commit') {
-                    // Commit: use single commit
-                    console.log(chalk_1.default.gray(`📝 Collecting git changes for commit: ${autoTarget.value}...`));
-                    gitDiff = await (0, diff_1.getCommitDiff)(repoRoot, autoTarget.value);
-                    reviewContext = { type: 'commit', value: autoTarget.value };
-                    commitSha = autoTarget.value;
-                    // Fetch commit message (reliable when we have SHA)
-                    const message = await (0, diff_1.getCommitMessage)(repoRoot, autoTarget.value);
-                    if (message) {
-                        commitMessage = message;
-                    }
-                }
-                else {
-                    // Fallback: local development
-                    console.log(chalk_1.default.gray('📝 Collecting git changes...'));
-                    gitDiff = await (0, diff_1.getGitDiff)(repoRoot);
-                }
-            }
-            else {
-                // Local development: use staged/unstaged changes
-                console.log(chalk_1.default.gray('📝 Collecting git changes...'));
-                gitDiff = await (0, diff_1.getGitDiff)(repoRoot);
-            }
+            // Auto-detect context based on environment
+            context = (0, context_1.detectContext)(environment);
+            const contextDesc = (0, git_diff_executor_1.getContextDescription)(context);
+            console.log(chalk_1.default.gray(`📝 Collecting git changes for ${contextDesc}...`));
+            gitDiff = await (0, git_diff_executor_1.getDiffForContext)(context, repoRoot, environment);
         }
+        // 3. Collect metadata (commit SHA, commit message, PR title)
+        const metadata = await (0, metadata_1.collectMetadata)(context, environment, repoRoot);
         if (gitDiff.changedFiles.length === 0) {
             console.log(chalk_1.default.yellow('⚠️  No changes detected. Make some code changes and try again.'));
             process.exit(0);
@@ -254,9 +177,7 @@ async function checkCommand(options) {
         const apiUrl = options.apiUrl ||
             process.env.THREADLINE_API_URL ||
             'https://devthreadline.com';
-        // 6. Detect environment
-        const environment = detectEnvironment();
-        // 7. Call review API
+        // 6. Call review API
         console.log(chalk_1.default.gray('🤖 Running threadline checks...'));
         const client = new client_1.ReviewAPIClient(apiUrl);
         const response = await client.review({
@@ -267,9 +188,9 @@ async function checkCommand(options) {
             account,
             repoName: repoName || undefined,
             branchName: branchName || undefined,
-            commitSha: commitSha,
-            commitMessage: commitMessage,
-            prTitle: prTitle,
+            commitSha: metadata.commitSha,
+            commitMessage: metadata.commitMessage,
+            prTitle: metadata.prTitle,
             environment: environment
         });
         // 7. Display results (with filtering if --full not specified)

package/dist/git/diff.js

@@ -71,20 +71,19 @@ async function getBranchDiff(repoRoot, branchName, baseBranch) {
             // 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']).catch(() => null);
-                if (previousCommit) {
-                    // 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
-                    };
-                }
+                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 {
+            catch (error) {
                 // If no previous commit, return empty (first commit)
+                console.log(`[DEBUG] No previous commit found (first commit or error): ${error.message || 'HEAD~1 does not exist'}`);
                 return {
                     diff: '',
                     changedFiles: []
@@ -96,51 +95,103 @@ async function getBranchDiff(repoRoot, branchName, baseBranch) {
     }
     // 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
     async function detectBaseBranch(git, branchName) {
-        // Try upstream tracking branch
-        const upstream = await git.revparse(['--abbrev-ref', '--symbolic-full-name', `${branchName}@{u}`]).catch(() => null);
-        if (upstream) {
-            // Extract base from upstream (e.g., "origin/main" -> check if local exists, else use "origin/main")
+        const isCI = !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.VERCEL || 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) {
-                // Check if local branch exists, otherwise use remote
-                const localExists = await git.revparse([upstreamBranch]).catch(() => null);
-                return localExists ? upstreamBranch : upstream;
+                // 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`);
             }
         }
-        // Try default branch
+        catch (error) {
+            console.log(`[DEBUG] Upstream tracking branch not set for '${branchName}': ${error.message || 'no upstream configured'}`);
+        }
+        // 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) {
-                // Check if local branch exists, otherwise use remote
-                const localExists = await git.revparse([defaultBranchName]).catch(() => null);
-                return localExists ? defaultBranchName : defaultBranch;
+                // 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 {
-            // Continue to fallback
+        catch (error) {
+            console.log(`[DEBUG] Default branch (refs/remotes/origin/HEAD) not configured: ${error.message || 'not found'}`);
         }
-        // Fallback to common names (excluding the branch itself)
+        // Strategy 3: Try common branch names by checking remote refs first (most reliable fallback)
+        // 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 {
-                // Check if remote exists
+                // Always check remote ref first (this is reliable in CI with fetch-depth: 0)
                 await git.revparse([`origin/${candidate}`]);
-                // Check if local exists, otherwise use remote
-                const localExists = await git.revparse([candidate]).catch(() => null);
-                return localExists ? candidate : `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 {
-                // Try next
+            catch (error) {
+                console.log(`[DEBUG] Remote branch 'origin/${candidate}' not found: ${error.message || 'does not exist'}`);
+                // Continue to next candidate
             }
         }
-        throw new Error(`Could not determine base branch for '${branchName}'. Please specify with --base flag or set upstream tracking.`);
+        // 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)

package/dist/utils/context.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Review Context Detection
+ *
+ * Determines what type of code review context we're in:
+ * - PR/MR: Multiple commits comparing two branches
+ * - Branch: All commits on a branch vs base branch
+ * - Commit: Single commit changes
+ * - Local: Staged/unstaged changes in working directory
+ *
+ * Context detection is environment-specific - each CI platform
+ * provides different environment variables.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectContext = detectContext;
+/**
+ * Detects the review context based on the environment.
+ *
+ * Each environment has different environment variables available,
+ * so detection logic is environment-specific.
+ */
+function detectContext(environment) {
+    switch (environment) {
+        case 'github':
+            return detectGitHubContext();
+        case 'gitlab':
+            return detectGitLabContext();
+        case 'vercel':
+            return detectVercelContext();
+        case 'local':
+            return { type: 'local' };
+        case 'azure-devops':
+            // Future: return detectAzureDevOpsContext();
+            return { type: 'local' };
+        default:
+            return { type: 'local' };
+    }
+}
+/**
+ * GitHub Actions context detection
+ *
+ * Environment Variables:
+ * - PR: GITHUB_EVENT_NAME='pull_request', GITHUB_BASE_REF, GITHUB_HEAD_REF, GITHUB_EVENT_NUMBER
+ * - Branch: GITHUB_REF_NAME
+ * - Commit: GITHUB_SHA
+ */
+function detectGitHubContext() {
+    // 1. Check for PR context
+    if (process.env.GITHUB_EVENT_NAME === 'pull_request') {
+        const targetBranch = process.env.GITHUB_BASE_REF;
+        const sourceBranch = process.env.GITHUB_HEAD_REF;
+        const prNumber = process.env.GITHUB_EVENT_PULL_REQUEST_NUMBER || process.env.GITHUB_EVENT_NUMBER;
+        if (targetBranch && sourceBranch && prNumber) {
+            return {
+                type: 'pr',
+                prNumber,
+                sourceBranch,
+                targetBranch
+            };
+        }
+    }
+    // 2. Check for branch context
+    if (process.env.GITHUB_REF_NAME) {
+        return {
+            type: 'branch',
+            branchName: process.env.GITHUB_REF_NAME
+        };
+    }
+    // 3. Check for commit context
+    if (process.env.GITHUB_SHA) {
+        return {
+            type: 'commit',
+            commitSha: process.env.GITHUB_SHA
+        };
+    }
+    // 4. Fallback to local
+    return { type: 'local' };
+}
+/**
+ * GitLab CI context detection
+ *
+ * Environment Variables:
+ * - MR: CI_MERGE_REQUEST_IID, CI_MERGE_REQUEST_TARGET_BRANCH_NAME, CI_MERGE_REQUEST_SOURCE_BRANCH_NAME, CI_MERGE_REQUEST_TITLE
+ * - Branch: CI_COMMIT_REF_NAME
+ * - Commit: CI_COMMIT_SHA
+ */
+function detectGitLabContext() {
+    // 1. Check for MR context
+    if (process.env.CI_MERGE_REQUEST_IID) {
+        const targetBranch = process.env.CI_MERGE_REQUEST_TARGET_BRANCH_NAME;
+        const sourceBranch = process.env.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME;
+        const mrNumber = process.env.CI_MERGE_REQUEST_IID;
+        const mrTitle = process.env.CI_MERGE_REQUEST_TITLE;
+        if (targetBranch && sourceBranch && mrNumber) {
+            return {
+                type: 'mr',
+                mrNumber,
+                sourceBranch,
+                targetBranch,
+                prTitle: mrTitle || undefined
+            };
+        }
+    }
+    // 2. Check for branch context
+    if (process.env.CI_COMMIT_REF_NAME) {
+        return {
+            type: 'branch',
+            branchName: process.env.CI_COMMIT_REF_NAME
+        };
+    }
+    // 3. Check for commit context
+    if (process.env.CI_COMMIT_SHA) {
+        return {
+            type: 'commit',
+            commitSha: process.env.CI_COMMIT_SHA
+        };
+    }
+    // 4. Fallback to local
+    return { type: 'local' };
+}
+/**
+ * Vercel context detection
+ *
+ * Environment Variables:
+ * - Branch: VERCEL_GIT_COMMIT_REF
+ * - Commit: VERCEL_GIT_COMMIT_SHA
+ */
+function detectVercelContext() {
+    // 1. Check for branch context
+    if (process.env.VERCEL_GIT_COMMIT_REF) {
+        return {
+            type: 'branch',
+            branchName: process.env.VERCEL_GIT_COMMIT_REF
+        };
+    }
+    // 2. Check for commit context
+    if (process.env.VERCEL_GIT_COMMIT_SHA) {
+        return {
+            type: 'commit',
+            commitSha: process.env.VERCEL_GIT_COMMIT_SHA
+        };
+    }
+    // 3. Fallback to local
+    return { type: 'local' };
+}

package/dist/utils/environment.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * CI/CD Environment Detection
+ *
+ * Detects which CI/CD platform or local environment the code is running in.
+ * This is the first step in determining how to collect context and metadata.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectEnvironment = detectEnvironment;
+exports.isCIEnvironment = isCIEnvironment;
+/**
+ * Detects the current environment based on environment variables.
+ *
+ * Detection order:
+ * 1. Vercel: VERCEL=1
+ * 2. GitHub Actions: GITHUB_ACTIONS=1
+ * 3. GitLab CI: GITLAB_CI=1 or (CI=1 + CI_COMMIT_SHA)
+ * 4. Azure DevOps: TF_BUILD=1 (future)
+ * 5. Local: None of the above
+ */
+function detectEnvironment() {
+    if (process.env.VERCEL)
+        return 'vercel';
+    if (process.env.GITHUB_ACTIONS)
+        return 'github';
+    if (process.env.GITLAB_CI || (process.env.CI && process.env.CI_COMMIT_SHA))
+        return 'gitlab';
+    // Future: if (process.env.TF_BUILD) return 'azure-devops';
+    return 'local';
+}
+/**
+ * Returns true if running in a CI/CD environment (not local)
+ */
+function isCIEnvironment(env) {
+    return env !== 'local';
+}

package/dist/utils/git-diff-executor.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Git Diff Execution
+ *
+ * Executes the appropriate git diff function based on review context.
+ * This is environment-agnostic - the git diff functions themselves
+ * handle environment-specific details (like base branch detection).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDiffForContext = getDiffForContext;
+exports.getContextDescription = getContextDescription;
+const diff_1 = require("../git/diff");
+/**
+ * Executes the appropriate git diff function based on context.
+ *
+ * This function maps context types to their corresponding git diff functions.
+ * The actual git diff functions handle environment-specific details internally.
+ */
+async function getDiffForContext(context, repoRoot, environment) {
+    switch (context.type) {
+        case 'pr':
+            return await (0, diff_1.getPRMRDiff)(repoRoot, context.sourceBranch, context.targetBranch);
+        case 'mr':
+            return await (0, diff_1.getPRMRDiff)(repoRoot, context.sourceBranch, context.targetBranch);
+        case 'branch':
+            return await (0, diff_1.getBranchDiff)(repoRoot, context.branchName);
+        case 'commit':
+            return await (0, diff_1.getCommitDiff)(repoRoot, context.commitSha);
+        case 'local':
+            return await (0, diff_1.getGitDiff)(repoRoot);
+        default:
+            // TypeScript exhaustiveness check - should never reach here
+            const _exhaustive = context;
+            throw new Error(`Unknown context type: ${_exhaustive}`);
+    }
+}
+/**
+ * Returns a human-readable description of the context for logging.
+ */
+function getContextDescription(context) {
+    switch (context.type) {
+        case 'pr':
+            return `PR: ${context.prNumber}`;
+        case 'mr':
+            return `MR: ${context.mrNumber}`;
+        case 'branch':
+            return `branch: ${context.branchName}`;
+        case 'commit':
+            return `commit: ${context.commitSha.substring(0, 7)}`;
+        case 'local':
+            return 'local changes';
+        default:
+            const _exhaustive = context;
+            throw new Error(`Unknown context type: ${_exhaustive}`);
+    }
+}

package/dist/utils/metadata.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Metadata Collection
+ *
+ * Collects environment-specific metadata for review context:
+ * - Commit SHA (from env vars or git)
+ * - Commit message (from git)
+ * - PR/MR title (from env vars or API)
+ *
+ * Metadata collection is environment-specific because each CI platform
+ * provides different environment variables.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectMetadata = collectMetadata;
+const diff_1 = require("../git/diff");
+/**
+ * Collects metadata for the given context and environment.
+ *
+ * This function knows how to extract metadata from each environment's
+ * specific environment variables and git commands.
+ */
+async function collectMetadata(context, environment, repoRoot) {
+    const metadata = {};
+    // Collect commit SHA (environment-specific)
+    metadata.commitSha = getCommitSha(context, environment);
+    // Collect commit message (if we have a commit SHA)
+    if (metadata.commitSha) {
+        const message = await (0, diff_1.getCommitMessage)(repoRoot, metadata.commitSha);
+        if (message) {
+            metadata.commitMessage = message;
+        }
+    }
+    // Collect PR/MR title (environment-specific)
+    metadata.prTitle = getPRTitle(context, environment);
+    return metadata;
+}
+/**
+ * Extracts commit SHA from context and environment.
+ */
+function getCommitSha(context, environment) {
+    // If context already has commit SHA, use it
+    if (context.type === 'commit') {
+        return context.commitSha;
+    }
+    // For branch contexts, try to get commit SHA from environment variables
+    if (context.type === 'branch') {
+        switch (environment) {
+            case 'github':
+                return process.env.GITHUB_SHA;
+            case 'gitlab':
+                return process.env.CI_COMMIT_SHA;
+            case 'vercel':
+                return process.env.VERCEL_GIT_COMMIT_SHA;
+            default:
+                return undefined;
+        }
+    }
+    // For PR/MR contexts, commit SHA might be available in env vars
+    if (context.type === 'pr' || context.type === 'mr') {
+        switch (environment) {
+            case 'github':
+                // For PRs, GITHUB_SHA is a merge commit, might want GITHUB_HEAD_SHA instead
+                return process.env.GITHUB_HEAD_SHA || process.env.GITHUB_SHA;
+            case 'gitlab':
+                return process.env.CI_COMMIT_SHA;
+            default:
+                return undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extracts PR/MR title from context and environment.
+ *
+ * Note: GitHub Actions doesn't provide PR title as an env var by default.
+ * It would need to be passed from the workflow YAML or fetched via API.
+ */
+function getPRTitle(context, environment) {
+    // Only PR/MR contexts have titles
+    if (context.type !== 'pr' && context.type !== 'mr') {
+        return undefined;
+    }
+    // GitLab CI provides MR title as env var
+    if (context.type === 'mr' && environment === 'gitlab') {
+        return context.prTitle;
+    }
+    // GitHub Actions doesn't provide PR title as env var
+    // Would need to be passed from workflow: PR_TITLE: ${{ github.event.pull_request.title }}
+    // or fetched via GitHub API
+    if (context.type === 'pr' && environment === 'github') {
+        return process.env.PR_TITLE; // Only if passed from workflow
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadlines",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "Threadline CLI - AI-powered linter based on your natural language documentation",
   "main": "dist/index.js",
   "bin": {