threadlines 0.1.19 → 0.1.21

package/dist/commands/check.js

@@ -126,11 +126,27 @@ async function checkCommand(options) {
             gitDiff = await (0, git_diff_executor_1.getDiffForContext)(context, repoRoot, environment);
         }
         else {
-            // 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);
+            // Auto-detect: Use environment-specific implementation
+            const envNames = {
+                vercel: 'Vercel',
+                github: 'GitHub',
+                gitlab: 'GitLab',
+                local: 'Local'
+            };
+            console.log(chalk_1.default.gray(`📝 Collecting git changes for ${envNames[environment]}...`));
+            gitDiff = await (0, git_diff_executor_1.getDiffForEnvironment)(environment, repoRoot);
+            // Create context for metadata collection
+            if (environment === 'vercel') {
+                context = { type: 'commit', commitSha: process.env.VERCEL_GIT_COMMIT_SHA };
+            }
+            else if (environment === 'github' || environment === 'gitlab') {
+                // GitHub/GitLab: Detect context for metadata (but diff already obtained)
+                context = (0, context_1.detectContext)(environment);
+            }
+            else {
+                // Local: Use local context
+                context = { type: 'local' };
+            }
         }
         // 3. Collect metadata (commit SHA, commit message, PR title)
         const metadata = await (0, metadata_1.collectMetadata)(context, environment, repoRoot);

package/dist/git/diff.js

@@ -3,49 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGitDiff = getGitDiff;
 exports.getBranchDiff = getBranchDiff;
 exports.getCommitMessage = getCommitMessage;
 exports.getCommitDiff = getCommitDiff;
 exports.getPRMRDiff = getPRMRDiff;
 const simple_git_1 = __importDefault(require("simple-git"));
-/**
- * Get diff for staged/unstaged changes (current behavior)
- */
-async function getGitDiff(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 diff (staged changes, or unstaged if no staged)
-    const status = await git.status();
-    let diff;
-    if (status.staged.length > 0) {
-        // Use staged changes
-        diff = await git.diff(['--cached', '-U200']);
-    }
-    else if (status.files.length > 0) {
-        // Use unstaged changes
-        diff = await git.diff(['-U200']);
-    }
-    else {
-        // No changes
-        return {
-            diff: '',
-            changedFiles: []
-        };
-    }
-    // Get list of changed files
-    const changedFiles = status.files
-        .filter(f => f.working_dir !== ' ' || f.index !== ' ')
-        .map(f => f.path);
-    return {
-        diff: diff || '',
-        changedFiles
-    };
-}
 /**
  * Get diff for a specific branch (all commits vs base branch)
  * Uses git merge-base to find common ancestor, then diffs from there
@@ -96,29 +58,9 @@ 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
+    // 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.VERCEL || process.env.GITLAB_CI);
-        const isVercel = !!process.env.VERCEL;
-        // Vercel-specific strategy: Try multiple approaches with clear logging
-        // Once we know what works, we'll remove the approaches that don't work
-        if (isVercel) {
-            console.log(`[DEBUG] Vercel environment detected - trying Vercel-specific base branch detection for '${branchName}'`);
-            // Strategy 3: Try using local main (maybe Vercel already has it checked out)
-            try {
-                console.log(`[DEBUG] Vercel: Checking if local 'main' branch exists...`);
-                await git.revparse(['main']);
-                console.log(`[DEBUG] Vercel: Found local 'main' branch - using as base`);
-                return 'main';
-            }
-            catch (error) {
-                console.log(`[DEBUG] Vercel: Local 'main' branch not found: ${error.message || 'does not exist'}`);
-            }
-            // All Vercel-specific strategies failed - fail loudly
-            throw new Error(`Vercel: Base branch 'main' is not available in the git repository. ` +
-                `Vercel CI does not have the base branch checked out or fetched. ` +
-                `Tried: local 'main' branch. ` +
-                `This is a Vercel CI limitation - the base branch needs to be available for comparison.`);
-        }
+        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}`]);

package/dist/git/github-diff.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitHubDiff = getGitHubDiff;
+const simple_git_1 = __importDefault(require("simple-git"));
+/**
+ * Get diff for GitHub Actions CI environment
+ *
+ * GitHub Actions provides environment variables that tell us exactly what to compare:
+ * - PR context: GITHUB_BASE_REF (target branch) and GITHUB_HEAD_REF (source branch)
+ * - Branch context: GITHUB_REF_NAME (current branch), compare against origin/main
+ *
+ * This is the ONLY implementation for GitHub - no fallbacks, no alternatives.
+ * If this doesn't work, we fail with a clear error.
+ */
+async function getGitHubDiff(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.');
+    }
+    // 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;
+    // PR context: GitHub provides both base and head branches
+    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.');
+        }
+        // Use the branches GitHub provides directly - no detection needed
+        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
+        };
+    }
+    // Branch context: GitHub provides branch name, compare against origin/main
+    if (refName) {
+        // For branch pushes, compare against origin/main (standard base branch)
+        // GitHub Actions with fetch-depth: 0 should have origin/main available
+        const diff = await git.diff([`origin/main...origin/${refName}`, '-U200']);
+        const diffSummary = await git.diffSummary([`origin/main...origin/${refName}`]);
+        const changedFiles = diffSummary.files.map(f => f.file);
+        return {
+            diff: diff || '',
+            changedFiles
+        };
+    }
+    // Neither PR nor branch context available
+    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.');
+}

package/dist/git/gitlab-diff.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitLabDiff = getGitLabDiff;
+const simple_git_1 = __importDefault(require("simple-git"));
+/**
+ * Get diff for GitLab CI environment
+ *
+ * GitLab CI provides environment variables that tell us exactly what to compare:
+ * - MR context: CI_MERGE_REQUEST_TARGET_BRANCH_NAME (target branch) and CI_MERGE_REQUEST_SOURCE_BRANCH_NAME (source branch)
+ * - Branch context: CI_COMMIT_REF_NAME (current branch), compare against origin/main
+ *
+ * This implementation follows the same pattern as GitHub Actions, using GitLab's equivalent
+ * environment variables. This is the ONLY implementation for GitLab - no fallbacks, no alternatives.
+ * If this doesn't work, we fail with a clear error.
+ */
+async function getGitLabDiff(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.');
+    }
+    // Determine context from 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;
+    // MR context: GitLab provides both target and source branches
+    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.');
+        }
+        // Use the branches GitLab provides directly - no detection needed
+        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
+        };
+    }
+    // Branch context: GitLab provides branch name, compare against origin/main
+    if (refName) {
+        // For branch pushes, compare against origin/main (standard base branch)
+        // GitLab CI with fetch-depth: 0 should have origin/main available
+        const diff = await git.diff([`origin/main...origin/${refName}`, '-U200']);
+        const diffSummary = await git.diffSummary([`origin/main...origin/${refName}`]);
+        const changedFiles = diffSummary.files.map(f => f.file);
+        return {
+            diff: diff || '',
+            changedFiles
+        };
+    }
+    // Neither MR nor branch context available
+    throw new Error('GitLab CI environment detected but no valid context found. ' +
+        'Expected CI_MERGE_REQUEST_IID (with CI_MERGE_REQUEST_TARGET_BRANCH_NAME/CI_MERGE_REQUEST_SOURCE_BRANCH_NAME) ' +
+        'or CI_COMMIT_REF_NAME for branch context.');
+}

package/dist/git/local-diff.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalDiff = getLocalDiff;
+const simple_git_1 = __importDefault(require("simple-git"));
+/**
+ * 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.
+ *
+ * This is the ONLY implementation for local - no fallbacks, no alternatives.
+ * If this doesn't work, we fail with a clear error.
+ */
+async function getLocalDiff(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 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
+    };
+}

package/dist/git/vercel-diff.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVercelDiff = getVercelDiff;
+const simple_git_1 = __importDefault(require("simple-git"));
+/**
+ * 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.
+ *
+ * This is the ONLY implementation for Vercel - no fallbacks, no alternatives.
+ * If this doesn't work, we fail with a clear error.
+ */
+async function getVercelDiff(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 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
+    };
+}

package/dist/utils/context.js

@@ -29,9 +29,6 @@ function detectContext(environment) {
             return detectVercelContext();
         case 'local':
             return { type: 'local' };
-        case 'azure-devops':
-            // Future: return detectAzureDevOpsContext();
-            return { type: 'local' };
         default:
             return { type: 'local' };
     }
@@ -124,22 +121,28 @@ function detectGitLabContext() {
  * Environment Variables:
  * - Branch: VERCEL_GIT_COMMIT_REF
  * - Commit: VERCEL_GIT_COMMIT_SHA
+ *
+ * Vercel Limitation:
+ * Vercel performs shallow clones of the repository, typically fetching only the
+ * specific commit being deployed. The git repository in Vercel's build environment
+ * does not contain the full git history or remote branch references (e.g., origin/main).
+ * This means branch-based diff operations (comparing feature branch against base branch)
+ * are not possible because the base branch refs are not available in the repository.
+ *
+ * Solution:
+ * We hardcode commit context for Vercel, using VERCEL_GIT_COMMIT_SHA to get a
+ * commit-based diff (comparing the commit against its parent). This works within
+ * Vercel's constraints since we only need the commit SHA, not branch references.
  */
 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
+    // Hardcode commit context for Vercel due to shallow clone limitations
+    // Vercel's git repository doesn't have base branch refs available
     if (process.env.VERCEL_GIT_COMMIT_SHA) {
         return {
             type: 'commit',
             commitSha: process.env.VERCEL_GIT_COMMIT_SHA
         };
     }
-    // 3. Fallback to local
+    // Fallback to local
     return { type: 'local' };
 }

package/dist/utils/environment.js

@@ -15,8 +15,7 @@ exports.isCIEnvironment = isCIEnvironment;
  * 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
+ * 4. Local: None of the above
  */
 function detectEnvironment() {
     if (process.env.VERCEL)
@@ -25,7 +24,6 @@ function detectEnvironment() {
         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';
 }
 /**

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

@@ -2,21 +2,62 @@
 /**
  * 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).
+ * Executes the appropriate git diff function based on environment.
+ * Each environment has ONE SINGLE IMPLEMENTATION - no fallbacks, no alternatives.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDiffForEnvironment = getDiffForEnvironment;
 exports.getDiffForContext = getDiffForContext;
 exports.getContextDescription = getContextDescription;
 const diff_1 = require("../git/diff");
+const vercel_diff_1 = require("../git/vercel-diff");
+const github_diff_1 = require("../git/github-diff");
+const local_diff_1 = require("../git/local-diff");
+const gitlab_diff_1 = require("../git/gitlab-diff");
 /**
- * Executes the appropriate git diff function based on context.
+ * Executes the appropriate git diff function based on environment.
  *
- * This function maps context types to their corresponding git diff functions.
- * The actual git diff functions handle environment-specific details internally.
+ * Each environment has a single, specific implementation:
+ * - Vercel: Uses VERCEL_GIT_COMMIT_SHA, gets commit diff via git show
+ * - GitHub: Uses GITHUB_BASE_REF/GITHUB_HEAD_REF for PRs, GITHUB_REF_NAME for branches
+ * - GitLab: Uses CI_MERGE_REQUEST_TARGET_BRANCH_NAME/CI_MERGE_REQUEST_SOURCE_BRANCH_NAME for MRs, CI_COMMIT_REF_NAME for branches
+ * - Local: Uses staged changes first, then unstaged changes
+ *
+ * No fallbacks - if the environment-specific implementation fails, we fail clearly.
+ * Each environment is completely isolated - changes to one don't affect others.
+ */
+async function getDiffForEnvironment(environment, repoRoot, context) {
+    switch (environment) {
+        case 'vercel':
+            // Vercel: Single implementation using commit SHA
+            return await (0, vercel_diff_1.getVercelDiff)(repoRoot);
+        case 'github':
+            // GitHub: Single implementation using GitHub-provided environment variables
+            return await (0, github_diff_1.getGitHubDiff)(repoRoot);
+        case 'gitlab':
+            // GitLab: Single implementation using GitLab-provided environment variables
+            return await (0, gitlab_diff_1.getGitLabDiff)(repoRoot);
+        case 'local':
+            // Local: Single implementation using staged/unstaged changes
+            return await (0, local_diff_1.getLocalDiff)(repoRoot);
+        default:
+            const _exhaustive = environment;
+            throw new Error(`Unknown environment: ${_exhaustive}`);
+    }
+}
+/**
+ * Legacy GitLab-specific diff function (deprecated).
+ *
+ * This function is kept for backward compatibility but should not be used.
+ * GitLab now uses getDiffForEnvironment() which routes to getGitLabDiff().
+ *
+ * @deprecated Use getDiffForEnvironment('gitlab', repoRoot) instead
  */
 async function getDiffForContext(context, repoRoot, environment) {
+    // This should only be called for GitLab legacy code paths
+    if (environment !== 'gitlab') {
+        throw new Error(`getDiffForContext() is deprecated. Use getDiffForEnvironment('${environment}', repoRoot) instead.`);
+    }
     switch (context.type) {
         case 'pr':
             return await (0, diff_1.getPRMRDiff)(repoRoot, context.sourceBranch, context.targetBranch);
@@ -27,7 +68,7 @@ async function getDiffForContext(context, repoRoot, environment) {
         case 'commit':
             return await (0, diff_1.getCommitDiff)(repoRoot, context.commitSha);
         case 'local':
-            return await (0, diff_1.getGitDiff)(repoRoot);
+            throw new Error('Local context should use getDiffForEnvironment(), not getDiffForContext()');
         default:
             // TypeScript exhaustiveness check - should never reach here
             const _exhaustive = context;

package/package.json

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