threadlines 0.1.34 → 0.1.36

package/dist/commands/check.js

@@ -42,10 +42,11 @@ const file_1 = require("../git/file");
 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 github_1 = require("../git/github");
+const gitlab_1 = require("../git/gitlab");
+const vercel_1 = require("../git/vercel");
+const local_1 = require("../git/local");
 const git_diff_executor_1 = require("../utils/git-diff-executor");
-const context_2 = require("../git/context");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
@@ -108,6 +109,7 @@ async function checkCommand(options) {
         let gitDiff;
         let repoName;
         let branchName;
+        let metadata = {};
         // Validate mutually exclusive flags
         const explicitFlags = [options.branch, options.commit, options.file, options.folder, options.files].filter(Boolean);
         if (explicitFlags.length > 1) {
@@ -138,22 +140,108 @@ async function checkCommand(options) {
             console.log(chalk_1.default.gray(`📝 Collecting git changes for branch: ${options.branch}...`));
             context = { type: 'branch', branchName: options.branch };
             gitDiff = await (0, git_diff_executor_1.getDiffForContext)(context, repoRoot, environment);
-            // Get repo/branch using unified approach
-            const gitContext = await (0, context_2.getGitContextForEnvironment)(environment, repoRoot);
-            repoName = gitContext.repoName;
-            branchName = gitContext.branchName;
+            // Get repo/branch using environment-specific approach
+            if (environment === 'github') {
+                const gitContext = await (0, github_1.getGitHubContext)(repoRoot);
+                repoName = gitContext.repoName;
+                branchName = gitContext.branchName;
+                metadata = {
+                    commitSha: gitContext.commitSha,
+                    commitMessage: gitContext.commitMessage,
+                    commitAuthorName: gitContext.commitAuthor.name,
+                    commitAuthorEmail: gitContext.commitAuthor.email,
+                    prTitle: gitContext.prTitle
+                };
+            }
+            else if (environment === 'gitlab') {
+                const gitContext = await (0, gitlab_1.getGitLabContext)(repoRoot);
+                repoName = gitContext.repoName;
+                branchName = gitContext.branchName;
+                metadata = {
+                    commitSha: gitContext.commitSha,
+                    commitMessage: gitContext.commitMessage,
+                    commitAuthorName: gitContext.commitAuthor.name,
+                    commitAuthorEmail: gitContext.commitAuthor.email,
+                    prTitle: gitContext.prTitle
+                };
+            }
+            else if (environment === 'vercel') {
+                const gitContext = await (0, vercel_1.getVercelContext)(repoRoot);
+                repoName = gitContext.repoName;
+                branchName = gitContext.branchName;
+                metadata = {
+                    commitSha: gitContext.commitSha,
+                    commitMessage: gitContext.commitMessage,
+                    commitAuthorName: gitContext.commitAuthor.name,
+                    commitAuthorEmail: gitContext.commitAuthor.email
+                };
+            }
+            else {
+                const gitContext = await (0, local_1.getLocalContext)(repoRoot);
+                repoName = gitContext.repoName;
+                branchName = gitContext.branchName;
+                metadata = {
+                    commitSha: gitContext.commitSha,
+                    commitMessage: gitContext.commitMessage,
+                    commitAuthorName: gitContext.commitAuthor.name,
+                    commitAuthorEmail: gitContext.commitAuthor.email
+                };
+            }
         }
         else if (options.commit) {
             console.log(chalk_1.default.gray(`📝 Collecting git changes for commit: ${options.commit}...`));
             context = { type: 'commit', commitSha: options.commit };
             gitDiff = await (0, git_diff_executor_1.getDiffForContext)(context, repoRoot, environment);
-            // Get repo/branch using unified approach
-            const gitContext = await (0, context_2.getGitContextForEnvironment)(environment, repoRoot);
-            repoName = gitContext.repoName;
-            branchName = gitContext.branchName;
+            // Get repo/branch using environment-specific approach
+            if (environment === 'github') {
+                const gitContext = await (0, github_1.getGitHubContext)(repoRoot);
+                repoName = gitContext.repoName;
+                branchName = gitContext.branchName;
+                metadata = {
+                    commitSha: gitContext.commitSha,
+                    commitMessage: gitContext.commitMessage,
+                    commitAuthorName: gitContext.commitAuthor.name,
+                    commitAuthorEmail: gitContext.commitAuthor.email,
+                    prTitle: gitContext.prTitle
+                };
+            }
+            else if (environment === 'gitlab') {
+                const gitContext = await (0, gitlab_1.getGitLabContext)(repoRoot);
+                repoName = gitContext.repoName;
+                branchName = gitContext.branchName;
+                metadata = {
+                    commitSha: gitContext.commitSha,
+                    commitMessage: gitContext.commitMessage,
+                    commitAuthorName: gitContext.commitAuthor.name,
+                    commitAuthorEmail: gitContext.commitAuthor.email,
+                    prTitle: gitContext.prTitle
+                };
+            }
+            else if (environment === 'vercel') {
+                const gitContext = await (0, vercel_1.getVercelContext)(repoRoot);
+                repoName = gitContext.repoName;
+                branchName = gitContext.branchName;
+                metadata = {
+                    commitSha: gitContext.commitSha,
+                    commitMessage: gitContext.commitMessage,
+                    commitAuthorName: gitContext.commitAuthor.name,
+                    commitAuthorEmail: gitContext.commitAuthor.email
+                };
+            }
+            else {
+                const gitContext = await (0, local_1.getLocalContext)(repoRoot, options.commit);
+                repoName = gitContext.repoName;
+                branchName = gitContext.branchName;
+                metadata = {
+                    commitSha: gitContext.commitSha,
+                    commitMessage: gitContext.commitMessage,
+                    commitAuthorName: gitContext.commitAuthor.name,
+                    commitAuthorEmail: gitContext.commitAuthor.email
+                };
+            }
         }
         else {
-            // Auto-detect: Use unified git context collection
+            // Auto-detect: Use environment-specific context collection (completely isolated)
             const envNames = {
                 vercel: 'Vercel',
                 github: 'GitHub',
@@ -161,33 +249,32 @@ async function checkCommand(options) {
                 local: 'Local'
             };
             console.log(chalk_1.default.gray(`📝 Collecting git context for ${envNames[environment]}...`));
-            // Use unified git context collection (diff + repo + branch)
-            const gitContext = await (0, context_2.getGitContextForEnvironment)(environment, repoRoot);
-            gitDiff = gitContext.diff;
-            repoName = gitContext.repoName;
-            branchName = gitContext.branchName;
-            // Create context for metadata collection
-            if (environment === 'vercel') {
-                context = { type: 'commit', commitSha: process.env.VERCEL_GIT_COMMIT_SHA };
+            // Get all context from environment-specific module
+            let envContext;
+            if (environment === 'github') {
+                envContext = await (0, github_1.getGitHubContext)(repoRoot);
+            }
+            else if (environment === 'gitlab') {
+                envContext = await (0, gitlab_1.getGitLabContext)(repoRoot);
             }
-            else if (environment === 'github' || environment === 'gitlab') {
-                // GitHub/GitLab: Detect context for metadata (but diff already obtained)
-                context = (0, context_1.detectContext)(environment);
+            else if (environment === 'vercel') {
+                envContext = await (0, vercel_1.getVercelContext)(repoRoot);
             }
             else {
-                // Local: Use local context
-                context = { type: 'local' };
+                envContext = await (0, local_1.getLocalContext)(repoRoot);
             }
-        }
-        // 3. Collect metadata (commit SHA, commit message, PR title)
-        const metadata = await (0, metadata_1.collectMetadata)(context, environment, repoRoot);
-        // Debug: Log collected metadata
-        console.log(`[DEBUG] Metadata after collectMetadata: ${JSON.stringify(metadata)}`);
-        if (metadata.commitAuthorName || metadata.commitAuthorEmail) {
-            console.log(chalk_1.default.gray(`   Author: ${metadata.commitAuthorName} <${metadata.commitAuthorEmail}>`));
-        }
-        else {
-            console.log(`[DEBUG] No author info - commitAuthorName=${metadata.commitAuthorName}, commitAuthorEmail=${metadata.commitAuthorEmail}`);
+            gitDiff = envContext.diff;
+            repoName = envContext.repoName;
+            branchName = envContext.branchName;
+            context = envContext.context;
+            // Use metadata from environment context
+            metadata = {
+                commitSha: envContext.commitSha,
+                commitMessage: envContext.commitMessage,
+                commitAuthorName: envContext.commitAuthor.name,
+                commitAuthorEmail: envContext.commitAuthor.email,
+                prTitle: envContext.prTitle
+            };
         }
         if (gitDiff.changedFiles.length === 0) {
             console.error(chalk_1.default.red('❌ Error: No changes detected.'));
@@ -233,7 +320,7 @@ async function checkCommand(options) {
         // 6. Call review API
         console.log(chalk_1.default.gray('🤖 Running threadline checks...'));
         const client = new client_1.ReviewAPIClient(apiUrl);
-        const reviewRequest = {
+        const response = await client.review({
             threadlines: threadlinesWithContext,
             diff: gitDiff.diff,
             files: gitDiff.changedFiles,
@@ -246,10 +333,9 @@ async function checkCommand(options) {
             commitAuthorName: metadata.commitAuthorName,
             commitAuthorEmail: metadata.commitAuthorEmail,
             prTitle: metadata.prTitle,
-            environment: environment
-        };
-        console.log(`[DEBUG] Sending to API - commitAuthorName: ${reviewRequest.commitAuthorName}, commitAuthorEmail: ${reviewRequest.commitAuthorEmail}`);
-        const response = await client.review(reviewRequest);
+            environment: environment,
+            cliVersion: CLI_VERSION
+        });
         // 7. Display results (with filtering if --full not specified)
         displayResults(response, options.full || false);
         // Exit with appropriate code

package/dist/git/github.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * GitHub Actions Environment - Complete Isolation
+ *
+ * All GitHub-specific logic is contained in this file.
+ * No dependencies on other environment implementations.
+ *
+ * Exports a single function: getGitHubContext() that returns:
+ * - diff: GitDiffResult
+ * - repoName: string
+ * - branchName: string
+ * - commitAuthor: { name: string; email: string }
+ * - prTitle?: string
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitHubContext = getGitHubContext;
+const simple_git_1 = __importDefault(require("simple-git"));
+const fs = __importStar(require("fs"));
+const repo_1 = require("./repo");
+const diff_1 = require("./diff");
+/**
+ * Gets all GitHub context in one call - completely isolated from other environments.
+ */
+async function getGitHubContext(repoRoot) {
+    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 all GitHub context
+    const diff = await getDiff(repoRoot);
+    const repoName = await getRepoName();
+    const branchName = await getBranchName();
+    const context = detectContext();
+    const commitSha = getCommitSha(context);
+    // Get commit author (fails loudly if unavailable)
+    // Note: commitSha parameter not needed - GitHub reads from GITHUB_EVENT_PATH JSON
+    const commitAuthor = await getCommitAuthor();
+    // Get commit message if we have a SHA
+    let commitMessage;
+    if (commitSha) {
+        const message = await (0, diff_1.getCommitMessage)(repoRoot, commitSha);
+        if (message) {
+            commitMessage = message;
+        }
+    }
+    // Get PR title if in PR context
+    const prTitle = getPRTitle(context);
+    return {
+        diff,
+        repoName,
+        branchName,
+        commitSha,
+        commitMessage,
+        commitAuthor,
+        prTitle,
+        context
+    };
+}
+/**
+ * Gets diff for GitHub Actions CI environment
+ */
+async function getDiff(repoRoot) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    const defaultBranch = await (0, repo_1.getDefaultBranchName)(repoRoot);
+    // Determine context from GitHub environment variables
+    const eventName = process.env.GITHUB_EVENT_NAME;
+    const baseRef = process.env.GITHUB_BASE_REF;
+    const headRef = process.env.GITHUB_HEAD_REF;
+    const refName = process.env.GITHUB_REF_NAME;
+    const commitSha = process.env.GITHUB_SHA;
+    // Scenario 1: PR Context
+    if (eventName === 'pull_request') {
+        if (!baseRef || !headRef) {
+            throw new Error('GitHub PR context detected but GITHUB_BASE_REF or GITHUB_HEAD_REF is missing. ' +
+                'This should be automatically provided by GitHub Actions.');
+        }
+        const diff = await git.diff([`origin/${baseRef}...origin/${headRef}`, '-U200']);
+        const diffSummary = await git.diffSummary([`origin/${baseRef}...origin/${headRef}`]);
+        const changedFiles = diffSummary.files.map(f => f.file);
+        return {
+            diff: diff || '',
+            changedFiles
+        };
+    }
+    // Scenario 2 & 4: Default Branch Push
+    if (refName === defaultBranch && commitSha) {
+        try {
+            const diff = await git.diff([`origin/${defaultBranch}~1...origin/${defaultBranch}`, '-U200']);
+            const diffSummary = await git.diffSummary([`origin/${defaultBranch}~1...origin/${defaultBranch}`]);
+            const changedFiles = diffSummary.files.map(f => f.file);
+            return {
+                diff: diff || '',
+                changedFiles
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Could not get diff for default branch '${defaultBranch}'. ` +
+                `This might be the first commit on the branch. Error: ${errorMessage}`);
+        }
+    }
+    // Scenario 3: Feature Branch Push
+    if (refName) {
+        const diff = await git.diff([`origin/${defaultBranch}...origin/${refName}`, '-U200']);
+        const diffSummary = await git.diffSummary([`origin/${defaultBranch}...origin/${refName}`]);
+        const changedFiles = diffSummary.files.map(f => f.file);
+        return {
+            diff: diff || '',
+            changedFiles
+        };
+    }
+    throw new Error('GitHub Actions environment detected but no valid context found. ' +
+        'Expected GITHUB_EVENT_NAME="pull_request" (with GITHUB_BASE_REF/GITHUB_HEAD_REF) ' +
+        'or GITHUB_REF_NAME for branch context.');
+}
+/**
+ * Gets repository name for GitHub Actions
+ */
+async function getRepoName() {
+    const githubRepo = process.env.GITHUB_REPOSITORY;
+    if (!githubRepo) {
+        throw new Error('GitHub Actions: GITHUB_REPOSITORY environment variable is not set. ' +
+            'This should be automatically provided by GitHub Actions.');
+    }
+    const serverUrl = process.env.GITHUB_SERVER_URL || 'https://github.com';
+    return `${serverUrl}/${githubRepo}.git`;
+}
+/**
+ * Gets branch name for GitHub Actions
+ */
+async function getBranchName() {
+    const refName = process.env.GITHUB_REF_NAME;
+    if (!refName) {
+        throw new Error('GitHub Actions: GITHUB_REF_NAME environment variable is not set. ' +
+            'This should be automatically provided by GitHub Actions.');
+    }
+    return refName;
+}
+/**
+ * Detects GitHub context (PR, branch, or commit)
+ */
+function detectContext() {
+    // 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 (shouldn't happen in GitHub Actions, but TypeScript needs it)
+    return { type: 'local' };
+}
+/**
+ * Gets commit SHA from context
+ */
+function getCommitSha(context) {
+    if (context.type === 'commit') {
+        return context.commitSha;
+    }
+    if (context.type === 'branch' || context.type === 'pr') {
+        return process.env.GITHUB_SHA;
+    }
+    return undefined;
+}
+/**
+ * Gets commit author for GitHub Actions
+ * Reads from GITHUB_EVENT_PATH JSON file (most reliable)
+ * Note: commitSha parameter not used - GitHub provides author info in event JSON
+ */
+async function getCommitAuthor() {
+    const eventPath = process.env.GITHUB_EVENT_PATH;
+    if (!eventPath) {
+        throw new Error('GitHub Actions: GITHUB_EVENT_PATH environment variable is not set. ' +
+            'This should be automatically provided by GitHub Actions.');
+    }
+    if (!fs.existsSync(eventPath)) {
+        throw new Error(`GitHub Actions: GITHUB_EVENT_PATH file does not exist: ${eventPath}. ` +
+            'This should be automatically provided by GitHub Actions.');
+    }
+    try {
+        const eventData = JSON.parse(fs.readFileSync(eventPath, 'utf-8'));
+        // For push events, use head_commit.author
+        if (eventData.head_commit?.author) {
+            return {
+                name: eventData.head_commit.author.name,
+                email: eventData.head_commit.author.email
+            };
+        }
+        // For PR events, use commits[0].author (first commit in the PR)
+        if (eventData.commits && eventData.commits.length > 0 && eventData.commits[0].author) {
+            return {
+                name: eventData.commits[0].author.name,
+                email: eventData.commits[0].author.email
+            };
+        }
+        // Fallback to pull_request.head.commit.author for PR events
+        if (eventData.pull_request?.head?.commit?.author) {
+            return {
+                name: eventData.pull_request.head.commit.author.name,
+                email: eventData.pull_request.head.commit.author.email
+            };
+        }
+        // If we get here, the event JSON doesn't contain author info
+        throw new Error(`GitHub Actions: GITHUB_EVENT_PATH JSON does not contain commit author information. ` +
+            `Event type: ${eventData.action || 'unknown'}. ` +
+            `This should be automatically provided by GitHub Actions.`);
+    }
+    catch (error) {
+        // If JSON parsing fails, fail loudly
+        if (error instanceof Error && error.message.includes('GitHub Actions:')) {
+            throw error; // Re-throw our own errors
+        }
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`GitHub Actions: Failed to read or parse GITHUB_EVENT_PATH JSON: ${errorMessage}. ` +
+            'This should be automatically provided by GitHub Actions.');
+    }
+}
+/**
+ * Gets PR title for GitHub Actions
+ * 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) {
+    if (context.type !== 'pr') {
+        return undefined;
+    }
+    // Only if passed from workflow: PR_TITLE: ${{ github.event.pull_request.title }}
+    return process.env.PR_TITLE;
+}

package/dist/git/gitlab.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * GitLab CI Environment - Complete Isolation
+ *
+ * All GitLab-specific logic is contained in this file.
+ * No dependencies on other environment implementations.
+ *
+ * Exports a single function: getGitLabContext() that returns:
+ * - diff: GitDiffResult
+ * - repoName: string
+ * - branchName: string
+ * - commitAuthor: { name: string; email: string }
+ * - prTitle?: string (MR title)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitLabContext = getGitLabContext;
+const simple_git_1 = __importDefault(require("simple-git"));
+const diff_1 = require("./diff");
+/**
+ * Gets all GitLab context in one call - completely isolated from other environments.
+ */
+async function getGitLabContext(repoRoot) {
+    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 all GitLab context
+    const diff = await getDiff(repoRoot);
+    const repoName = await getRepoName();
+    const branchName = await getBranchName();
+    const context = detectContext();
+    const commitSha = getCommitSha(context);
+    // Get commit author (fails loudly if unavailable)
+    const commitAuthor = await getCommitAuthor();
+    // Get commit message if we have a SHA
+    let commitMessage;
+    if (commitSha) {
+        const message = await (0, diff_1.getCommitMessage)(repoRoot, commitSha);
+        if (message) {
+            commitMessage = message;
+        }
+    }
+    // Get MR title if in MR context
+    const prTitle = getMRTitle(context);
+    return {
+        diff,
+        repoName,
+        branchName,
+        commitSha,
+        commitMessage,
+        commitAuthor,
+        prTitle,
+        context
+    };
+}
+/**
+ * Get diff for GitLab CI environment
+ *
+ * GitLab CI does a shallow clone of ONLY the current branch. The default branch
+ * (e.g., origin/main) is NOT available by default. We fetch it on-demand.
+ *
+ * Scenarios handled:
+ *
+ * 1. MR Context (CI_MERGE_REQUEST_IID is set):
+ *    - Fetch target branch, then diff target vs source
+ *
+ * 2. Feature Branch Push (CI_COMMIT_REF_NAME != CI_DEFAULT_BRANCH):
+ *    - Fetch default branch, then diff default vs feature
+ *
+ * 3. Default Branch Push (CI_COMMIT_REF_NAME == CI_DEFAULT_BRANCH):
+ *    - Use HEAD~1...HEAD (last commit only, no fetch needed)
+ */
+async function getDiff(repoRoot) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    // Get GitLab CI environment variables
+    const mrIid = 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 refName = process.env.CI_COMMIT_REF_NAME;
+    const defaultBranch = process.env.CI_DEFAULT_BRANCH || 'main';
+    // Scenario 1: MR Context
+    if (mrIid) {
+        if (!targetBranch || !sourceBranch) {
+            throw new Error('GitLab MR context detected but CI_MERGE_REQUEST_TARGET_BRANCH_NAME or ' +
+                'CI_MERGE_REQUEST_SOURCE_BRANCH_NAME is missing. ' +
+                'This should be automatically provided by GitLab CI.');
+        }
+        console.log(`  [GitLab] Fetching target branch: origin/${targetBranch}`);
+        await git.fetch(['origin', `${targetBranch}:refs/remotes/origin/${targetBranch}`, '--depth=1']);
+        const diff = await git.diff([`origin/${targetBranch}...origin/${sourceBranch}`, '-U200']);
+        const diffSummary = await git.diffSummary([`origin/${targetBranch}...origin/${sourceBranch}`]);
+        const changedFiles = diffSummary.files.map(f => f.file);
+        return { diff: diff || '', changedFiles };
+    }
+    if (!refName) {
+        throw new Error('GitLab CI: CI_COMMIT_REF_NAME environment variable is not set. ' +
+            'This should be automatically provided by GitLab CI.');
+    }
+    // Scenario 3: Default Branch Push
+    if (refName === defaultBranch) {
+        console.log(`  [GitLab] Push to default branch (${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 };
+    }
+    // Scenario 2: Feature Branch Push
+    console.log(`  [GitLab] Feature branch push, fetching default branch: origin/${defaultBranch}`);
+    await git.fetch(['origin', `${defaultBranch}:refs/remotes/origin/${defaultBranch}`, '--depth=1']);
+    const diff = await git.diff([`origin/${defaultBranch}...origin/${refName}`, '-U200']);
+    const diffSummary = await git.diffSummary([`origin/${defaultBranch}...origin/${refName}`]);
+    const changedFiles = diffSummary.files.map(f => f.file);
+    return { diff: diff || '', changedFiles };
+}
+/**
+ * Gets repository name for GitLab CI
+ */
+async function getRepoName() {
+    const projectUrl = process.env.CI_PROJECT_URL;
+    if (!projectUrl) {
+        throw new Error('GitLab CI: CI_PROJECT_URL environment variable is not set. ' +
+            'This should be automatically provided by GitLab CI.');
+    }
+    return `${projectUrl}.git`;
+}
+/**
+ * Gets branch name for GitLab CI
+ */
+async function getBranchName() {
+    const refName = process.env.CI_COMMIT_REF_NAME;
+    if (!refName) {
+        throw new Error('GitLab CI: CI_COMMIT_REF_NAME environment variable is not set. ' +
+            'This should be automatically provided by GitLab CI.');
+    }
+    return refName;
+}
+/**
+ * Detects GitLab context (MR, branch, or commit)
+ */
+function detectContext() {
+    // 1. Check for MR context
+    const mrIid = process.env.CI_MERGE_REQUEST_IID;
+    if (mrIid) {
+        const targetBranch = process.env.CI_MERGE_REQUEST_TARGET_BRANCH_NAME;
+        const sourceBranch = process.env.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME;
+        if (targetBranch && sourceBranch) {
+            return {
+                type: 'mr',
+                mrNumber: mrIid,
+                sourceBranch,
+                targetBranch
+            };
+        }
+    }
+    // 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 (shouldn't happen in GitLab CI, but TypeScript needs it)
+    return { type: 'local' };
+}
+/**
+ * Gets commit SHA from context
+ */
+function getCommitSha(context) {
+    if (context.type === 'commit') {
+        return context.commitSha;
+    }
+    if (context.type === 'branch' || context.type === 'mr') {
+        return process.env.CI_COMMIT_SHA;
+    }
+    return undefined;
+}
+/**
+ * Gets commit author for GitLab CI
+ * Uses CI_COMMIT_AUTHOR environment variable (most reliable)
+ */
+async function getCommitAuthor() {
+    const commitAuthor = process.env.CI_COMMIT_AUTHOR;
+    if (!commitAuthor) {
+        throw new Error('GitLab CI: CI_COMMIT_AUTHOR environment variable is not set. ' +
+            'This should be automatically provided by GitLab CI.');
+    }
+    // Parse "name <email>" format
+    const match = commitAuthor.match(/^(.+?)\s*<(.+?)>$/);
+    if (!match) {
+        throw new Error(`GitLab CI: CI_COMMIT_AUTHOR format is invalid. ` +
+            `Expected format: "name <email>", got: "${commitAuthor}". ` +
+            `This should be automatically provided by GitLab CI in the correct format.`);
+    }
+    return {
+        name: match[1].trim(),
+        email: match[2].trim()
+    };
+}
+/**
+ * Gets MR title for GitLab CI
+ */
+function getMRTitle(context) {
+    if (context.type !== 'mr') {
+        return undefined;
+    }
+    // GitLab CI provides MR title as env var
+    return process.env.CI_MERGE_REQUEST_TITLE;
+}

package/dist/git/local.js

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * Local Environment - Complete Isolation
+ *
+ * All Local-specific logic is contained in this file.
+ * No dependencies on other environment implementations.
+ *
+ * Exports a single function: getLocalContext() that returns:
+ * - diff: GitDiffResult
+ * - repoName: string
+ * - branchName: string
+ * - commitAuthor: { name: string; email: string }
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalContext = getLocalContext;
+const simple_git_1 = __importDefault(require("simple-git"));
+const diff_1 = require("./diff");
+/**
+ * Gets all Local context in one call - completely isolated from other environments.
+ */
+async function getLocalContext(repoRoot, commitSha) {
+    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 all Local context
+    const diff = commitSha ? await getCommitDiff(repoRoot, commitSha) : await getDiff(repoRoot);
+    const repoName = await getRepoName(repoRoot);
+    const branchName = await getBranchName(repoRoot);
+    const context = commitSha ? { type: 'commit', commitSha } : { type: 'local' };
+    // Get commit author (fails loudly if unavailable)
+    const commitAuthor = commitSha
+        ? await getCommitAuthorFromGit(repoRoot, commitSha)
+        : await getCommitAuthorFromConfig(repoRoot);
+    // Get commit message if we have a SHA
+    let commitMessage;
+    if (commitSha) {
+        const message = await (0, diff_1.getCommitMessage)(repoRoot, commitSha);
+        if (message) {
+            commitMessage = message;
+        }
+    }
+    return {
+        diff,
+        repoName,
+        branchName,
+        commitSha,
+        commitMessage,
+        commitAuthor,
+        prTitle: undefined, // Not applicable for local
+        context
+    };
+}
+/**
+ * Get diff for local development environment
+ *
+ * For local development, we check staged changes first, then unstaged changes.
+ * This allows developers to review what they've staged before committing,
+ * or review unstaged changes if nothing is staged.
+ */
+async function getDiff(repoRoot) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    // Get git status to determine what changes exist
+    const status = await git.status();
+    let diff;
+    let changedFiles;
+    // Priority 1: Use staged changes if available
+    if (status.staged.length > 0) {
+        diff = await git.diff(['--cached', '-U200']);
+        // status.staged is an array of strings (file paths)
+        changedFiles = status.staged;
+    }
+    // Priority 2: Use unstaged changes if no staged changes
+    else if (status.files.length > 0) {
+        diff = await git.diff(['-U200']);
+        changedFiles = status.files
+            .filter(f => f.working_dir !== ' ' || f.index !== ' ')
+            .map(f => f.path);
+    }
+    // No changes at all
+    else {
+        return {
+            diff: '',
+            changedFiles: []
+        };
+    }
+    return {
+        diff: diff || '',
+        changedFiles
+    };
+}
+/**
+ * Get diff for a specific commit (when --commit flag is used)
+ */
+async function getCommitDiff(repoRoot, commitSha) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    // Get diff using git show
+    const diff = await git.show([commitSha, '--format=', '--no-color', '-U200']);
+    // Get changed files using git show --name-only
+    const commitFiles = await git.show([commitSha, '--name-only', '--format=', '--pretty=format:']);
+    const changedFiles = commitFiles
+        .split('\n')
+        .filter(line => line.trim().length > 0)
+        .map(line => line.trim());
+    return {
+        diff: diff || '',
+        changedFiles
+    };
+}
+/**
+ * Gets repository name for local environment
+ */
+async function getRepoName(repoRoot) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    try {
+        const remotes = await git.getRemotes(true);
+        const origin = remotes.find(r => r.name === 'origin');
+        if (!origin || !origin.refs?.fetch) {
+            throw new Error('No origin remote found. Please set up a git remote named "origin".');
+        }
+        return origin.refs.fetch;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to get repository name from git remote: ${errorMessage}`);
+    }
+}
+/**
+ * Gets branch name for local environment
+ */
+async function getBranchName(repoRoot) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    try {
+        const branchSummary = await git.branchLocal();
+        const currentBranch = branchSummary.current;
+        if (!currentBranch) {
+            throw new Error('Could not determine current branch. Are you in a git repository?');
+        }
+        return currentBranch;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to get branch name: ${errorMessage}`);
+    }
+}
+/**
+ * Gets commit author from git config (for uncommitted changes)
+ * This represents who is currently working on the changes and will commit them.
+ *
+ * No fallbacks - if git config is not set or fails, throws an error.
+ */
+async function getCommitAuthorFromConfig(repoRoot) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    try {
+        const name = await git.getConfig('user.name');
+        const email = await git.getConfig('user.email');
+        if (!name.value || !email.value) {
+            throw new Error('Git config user.name or user.email is not set. ' +
+                'Run: git config user.name "Your Name" && git config user.email "your.email@example.com"');
+        }
+        return {
+            name: name.value.trim(),
+            email: email.value.trim()
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to get git config user: ${errorMessage}`);
+    }
+}
+/**
+ * Gets commit author from git log (for specific commits)
+ */
+async function getCommitAuthorFromGit(repoRoot, commitSha) {
+    const gitAuthor = await (0, diff_1.getCommitAuthor)(repoRoot, commitSha);
+    if (!gitAuthor || !gitAuthor.email) {
+        throw new Error(`Local: Failed to get commit author from git log for commit ${commitSha}. ` +
+            'This should be available in your local git repository.');
+    }
+    return {
+        name: gitAuthor.name,
+        email: gitAuthor.email
+    };
+}

package/dist/git/vercel.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Vercel Environment - Complete Isolation
+ *
+ * All Vercel-specific logic is contained in this file.
+ * No dependencies on other environment implementations.
+ *
+ * Exports a single function: getVercelContext() that returns:
+ * - diff: GitDiffResult
+ * - repoName: string
+ * - branchName: string
+ * - commitAuthor: { name: string; email: string }
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVercelContext = getVercelContext;
+const simple_git_1 = __importDefault(require("simple-git"));
+const diff_1 = require("./diff");
+/**
+ * Gets all Vercel context in one call - completely isolated from other environments.
+ */
+async function getVercelContext(repoRoot) {
+    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 all Vercel context
+    const diff = await getDiff(repoRoot);
+    const repoName = await getRepoName();
+    const branchName = await getBranchName();
+    const commitSha = getCommitSha();
+    const context = { type: 'commit', commitSha };
+    // Get commit author (fails loudly if unavailable)
+    const commitAuthor = await getCommitAuthorForVercel(repoRoot, commitSha);
+    // Get commit message
+    let commitMessage;
+    const message = await (0, diff_1.getCommitMessage)(repoRoot, commitSha);
+    if (message) {
+        commitMessage = message;
+    }
+    return {
+        diff,
+        repoName,
+        branchName,
+        commitSha,
+        commitMessage,
+        commitAuthor,
+        context
+    };
+}
+/**
+ * Get diff for Vercel CI environment
+ *
+ * Vercel provides VERCEL_GIT_COMMIT_SHA which contains the commit being deployed.
+ * This function gets the diff for that specific commit using git show.
+ */
+async function getDiff(repoRoot) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    // Get commit SHA from Vercel environment variable
+    const commitSha = process.env.VERCEL_GIT_COMMIT_SHA;
+    if (!commitSha) {
+        throw new Error('VERCEL_GIT_COMMIT_SHA environment variable is not set. ' +
+            'This should be automatically provided by Vercel CI.');
+    }
+    // Get diff using git show - this is the ONLY way we get diff in Vercel
+    const diff = await git.show([commitSha, '--format=', '--no-color', '-U200']);
+    // Get changed files using git show --name-only
+    const commitFiles = await git.show([commitSha, '--name-only', '--format=', '--pretty=format:']);
+    const changedFiles = commitFiles
+        .split('\n')
+        .filter(line => line.trim().length > 0)
+        .map(line => line.trim());
+    return {
+        diff: diff || '',
+        changedFiles
+    };
+}
+/**
+ * Gets repository name for Vercel
+ */
+async function getRepoName() {
+    const owner = process.env.VERCEL_GIT_REPO_OWNER;
+    const slug = process.env.VERCEL_GIT_REPO_SLUG;
+    if (!owner || !slug) {
+        throw new Error('Vercel: VERCEL_GIT_REPO_OWNER or VERCEL_GIT_REPO_SLUG environment variable is not set. ' +
+            'This should be automatically provided by Vercel CI.');
+    }
+    return `https://github.com/${owner}/${slug}.git`;
+}
+/**
+ * Gets branch name for Vercel
+ */
+async function getBranchName() {
+    const branchName = process.env.VERCEL_GIT_COMMIT_REF;
+    if (!branchName) {
+        throw new Error('Vercel: VERCEL_GIT_COMMIT_REF environment variable is not set. ' +
+            'This should be automatically provided by Vercel CI.');
+    }
+    return branchName;
+}
+/**
+ * Gets commit SHA for Vercel
+ */
+function getCommitSha() {
+    const commitSha = process.env.VERCEL_GIT_COMMIT_SHA;
+    if (!commitSha) {
+        throw new Error('Vercel: VERCEL_GIT_COMMIT_SHA environment variable is not set. ' +
+            'This should be automatically provided by Vercel CI.');
+    }
+    return commitSha;
+}
+/**
+ * Gets commit author for Vercel
+ * Uses VERCEL_GIT_COMMIT_AUTHOR_NAME for name, git log for email
+ */
+async function getCommitAuthorForVercel(repoRoot, commitSha) {
+    const authorName = process.env.VERCEL_GIT_COMMIT_AUTHOR_NAME;
+    if (!authorName) {
+        throw new Error('Vercel: VERCEL_GIT_COMMIT_AUTHOR_NAME environment variable is not set. ' +
+            'This should be automatically provided by Vercel.');
+    }
+    // Get email from git log - fail loudly if this doesn't work
+    const gitAuthor = await (0, diff_1.getCommitAuthor)(repoRoot, commitSha);
+    if (!gitAuthor || !gitAuthor.email) {
+        throw new Error(`Vercel: Failed to get commit author email from git log for commit ${commitSha}. ` +
+            `This should be available in Vercel's build environment.`);
+    }
+    return {
+        name: authorName.trim(),
+        email: gitAuthor.email.trim()
+    };
+}

package/dist/utils/metadata.js

@@ -67,23 +67,18 @@ async function collectMetadata(context, environment, repoRoot) {
         if (message) {
             metadata.commitMessage = message;
         }
-        // Get commit author - environment-specific approach
+        // Get commit author - environment-specific approach (fails loudly if unavailable)
         const author = await getCommitAuthorForEnvironment(environment, repoRoot, metadata.commitSha);
-        if (author) {
-            metadata.commitAuthorName = author.name;
-            metadata.commitAuthorEmail = author.email;
-        }
+        metadata.commitAuthorName = author.name;
+        metadata.commitAuthorEmail = author.email;
     }
     else {
         // For local environment without explicit commit SHA:
         // Use git config (who will commit staged/unstaged changes)
         // No fallbacks - if git config fails, the error propagates and fails the check
-        console.log('[DEBUG] Local environment - calling getGitConfigUser()');
         const author = await getGitConfigUser(repoRoot);
-        console.log(`[DEBUG] getGitConfigUser returned: ${JSON.stringify(author)}`);
         metadata.commitAuthorName = author.name;
         metadata.commitAuthorEmail = author.email;
-        console.log(`[DEBUG] metadata after assignment: commitAuthorName=${metadata.commitAuthorName}, commitAuthorEmail=${metadata.commitAuthorEmail}`);
     }
     // Collect PR/MR title (environment-specific)
     metadata.prTitle = getPRTitle(context, environment);
@@ -127,46 +122,63 @@ function getCommitSha(context, environment) {
 /**
  * Gets commit author information using environment-specific methods.
  *
- * For GitHub: Reads from GITHUB_EVENT_PATH JSON file (most reliable)
- * For GitLab: Uses CI_COMMIT_AUTHOR environment variable (most reliable)
- * For Local: Uses git config (for uncommitted changes, represents who will commit)
- * For other environments: Uses git log command
+ * Each environment has a single, isolated strategy:
+ * - GitHub: Reads from GITHUB_EVENT_PATH JSON file (fails loudly if unavailable)
+ * - GitLab: Uses CI_COMMIT_AUTHOR environment variable (fails loudly if unavailable)
+ * - Vercel: Uses VERCEL_GIT_COMMIT_AUTHOR_NAME + git log (fails loudly if unavailable)
+ * - Local: Uses git config (handled separately in collectMetadata, fails loudly if unavailable)
+ *
+ * No fallbacks - each environment is completely isolated.
  */
 async function getCommitAuthorForEnvironment(environment, repoRoot, commitSha) {
     if (environment === 'github') {
         // GitHub: Read from GITHUB_EVENT_PATH JSON file
         // This is more reliable than git commands, especially in shallow clones
         const eventPath = process.env.GITHUB_EVENT_PATH;
-        if (eventPath && fs.existsSync(eventPath)) {
-            try {
-                const eventData = JSON.parse(fs.readFileSync(eventPath, 'utf-8'));
-                // For push events, use head_commit.author
-                if (eventData.head_commit?.author) {
-                    return {
-                        name: eventData.head_commit.author.name,
-                        email: eventData.head_commit.author.email
-                    };
-                }
-                // For PR events, use commits[0].author (first commit in the PR)
-                if (eventData.commits && eventData.commits.length > 0 && eventData.commits[0].author) {
-                    return {
-                        name: eventData.commits[0].author.name,
-                        email: eventData.commits[0].author.email
-                    };
-                }
-                // Fallback to pull_request.head.commit.author for PR events
-                if (eventData.pull_request?.head?.commit?.author) {
-                    return {
-                        name: eventData.pull_request.head.commit.author.name,
-                        email: eventData.pull_request.head.commit.author.email
-                    };
-                }
+        if (!eventPath) {
+            throw new Error('GitHub Actions: GITHUB_EVENT_PATH environment variable is not set. ' +
+                'This should be automatically provided by GitHub Actions.');
+        }
+        if (!fs.existsSync(eventPath)) {
+            throw new Error(`GitHub Actions: GITHUB_EVENT_PATH file does not exist: ${eventPath}. ` +
+                'This should be automatically provided by GitHub Actions.');
+        }
+        try {
+            const eventData = JSON.parse(fs.readFileSync(eventPath, 'utf-8'));
+            // For push  events, use head_commit.author 
+            if (eventData.head_commit?.author) {
+                return {
+                    name: eventData.head_commit.author.name,
+                    email: eventData.head_commit.author.email
+                };
+            }
+            // For PR events, use commits[0].author (first commit in the PR)
+            if (eventData.commits && eventData.commits.length > 0 && eventData.commits[0].author) {
+                return {
+                    name: eventData.commits[0].author.name,
+                    email: eventData.commits[0].author.email
+                };
             }
-            catch (error) {
-                // If JSON parsing fails, fall through to git command
-                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                console.warn(`Warning: Failed to read GitHub event JSON: ${errorMessage}`);
+            // Fallback to pull_request.head.commit.author for PR events
+            if (eventData.pull_request?.head?.commit?.author) {
+                return {
+                    name: eventData.pull_request.head.commit.author.name,
+                    email: eventData.pull_request.head.commit.author.email
+                };
+            }
+            // If we get here, the event JSON doesn't contain author info
+            throw new Error(`GitHub Actions: GITHUB_EVENT_PATH JSON does not contain commit author information. ` +
+                `Event type: ${eventData.action || 'unknown'}. ` +
+                `This should be automatically provided by GitHub Actions.`);
+        }
+        catch (error) {
+            // If JSON parsing fails, fail loudly
+            if (error instanceof Error && error.message.includes('GitHub Actions:')) {
+                throw error; // Re-throw our own errors
             }
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`GitHub Actions: Failed to read or parse GITHUB_EVENT_PATH JSON: ${errorMessage}. ` +
+                'This should be automatically provided by GitHub Actions.');
         }
     }
     if (environment === 'gitlab') {
@@ -190,8 +202,43 @@ async function getCommitAuthorForEnvironment(environment, repoRoot, commitSha) {
             email: match[2].trim()
         };
     }
-    // Fallback to git command for all environments (including GitHub/GitLab if env vars unavailable)
-    return await (0, diff_1.getCommitAuthor)(repoRoot, commitSha);
+    if (environment === 'vercel') {
+        // Vercel: Use VERCEL_GIT_COMMIT_AUTHOR_NAME for name, git log for email
+        // Vercel provides author name but not email in environment variables
+        // git log works reliably in Vercel's build environment
+        const authorName = process.env.VERCEL_GIT_COMMIT_AUTHOR_NAME;
+        if (!authorName) {
+            throw new Error('Vercel: VERCEL_GIT_COMMIT_AUTHOR_NAME environment variable is not set. ' +
+                'This should be automatically provided by Vercel.');
+        }
+        // Get email from git log - fail loudly if this doesn't work
+        const gitAuthor = await (0, diff_1.getCommitAuthor)(repoRoot, commitSha);
+        if (!gitAuthor || !gitAuthor.email) {
+            throw new Error(`Vercel: Failed to get commit author email from git log for commit ${commitSha}. ` +
+                `This should be available in Vercel's build environment.`);
+        }
+        return {
+            name: authorName.trim(),
+            email: gitAuthor.email.trim()
+        };
+    }
+    // Local environment should not reach here - it's handled separately in collectMetadata
+    // when commitSha is undefined. If we get here with 'local', it means commitSha was set
+    // (e.g., --commit flag), so we can use git log.
+    if (environment === 'local') {
+        const gitAuthor = await (0, diff_1.getCommitAuthor)(repoRoot, commitSha);
+        if (!gitAuthor || !gitAuthor.email) {
+            throw new Error(`Local: Failed to get commit author from git log for commit ${commitSha}. ` +
+                'This should be available in your local git repository.');
+        }
+        return {
+            name: gitAuthor.name,
+            email: gitAuthor.email
+        };
+    }
+    // Unknown environment - this should never happen due to TypeScript exhaustiveness
+    const _exhaustive = environment;
+    throw new Error(`Unknown environment: ${_exhaustive}`);
 }
 /**
  * Gets git user info from git config (for local uncommitted changes).

package/package.json

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