threadlines 0.1.20 → 0.1.22

package/dist/commands/check.js

@@ -127,26 +127,34 @@ async function checkCommand(options) {
         }
         else {
             // 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') {
-                // Vercel: Direct environment-based routing (single implementation)
-                console.log(chalk_1.default.gray(`📝 Collecting git changes for Vercel commit...`));
-                gitDiff = await (0, git_diff_executor_1.getDiffForEnvironment)(environment, repoRoot);
-                // Vercel uses commit context, but we don't need to create it explicitly
                 context = { type: 'commit', commitSha: process.env.VERCEL_GIT_COMMIT_SHA };
             }
-            else {
-                // Other environments: Use context-based routing (legacy)
+            else if (environment === 'github' || environment === 'gitlab') {
+                // GitHub/GitLab: Detect context for metadata (but diff already obtained)
                 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);
+            }
+            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);
         if (gitDiff.changedFiles.length === 0) {
-            console.log(chalk_1.default.yellow('⚠️  No changes detected. Make some code changes and try again.'));
-            process.exit(0);
+            console.error(chalk_1.default.red('❌ Error: No changes detected.'));
+            console.error(chalk_1.default.red('   Threadline check requires code changes to analyze.'));
+            console.error(chalk_1.default.red('   This may indicate a problem with git diff detection.'));
+            process.exit(1);
         }
         // Check for zero diff (files changed but no actual code changes)
         if (!gitDiff.diff || gitDiff.diff.trim() === '') {

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

package/dist/git/github-diff.js

@@ -0,0 +1,109 @@
+"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"));
+const repo_1 = require("./repo");
+/**
+ * Get diff for GitHub Actions CI environment
+ *
+ * Handles four scenarios:
+ *
+ * 1. PR Context (pull_request event):
+ *    Uses GITHUB_BASE_REF vs GITHUB_HEAD_REF
+ *    Shows: All changes in the PR
+ *
+ * 2. Merge Commit to Default Branch (push event, default branch):
+ *    Compare: origin/default~1 vs origin/default
+ *    Shows: All changes that were merged in
+ *
+ * 3. Feature Branch Push (push event, feature branch):
+ *    Compare: origin/default vs origin/feature-branch
+ *    Shows: Cumulative changes in feature branch vs default
+ *
+ * 4. Direct Commit to Default Branch (push event, default branch, non-merge):
+ *    Compare: origin/default~1 vs origin/default
+ *    Shows: Changes in the direct commit
+ *
+  */
+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.');
+    }
+    // Detect the default branch name (e.g., "main", "master")
+    // This is used for scenarios 2, 3, and 4
+    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
+    // When a PR is created or updated, GitHub provides both base and head branches
+    // This is the simplest case - we use what GitHub gives us directly
+    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.');
+        }
+        // Compare target branch (base) vs source branch (head)
+        // This shows all changes in the PR
+        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 (merge commit or direct commit)
+    // When code is pushed to the default branch, we compare default~1 vs default
+    // This works for both merge commits and direct commits:
+    // - Merge commits: Shows all changes that were merged in
+    // - Direct commits: Shows the changes in the direct commit
+    if (refName === defaultBranch && commitSha) {
+        // Compare default branch before the push (default~1) vs default branch after the push (default)
+        // This shows all changes introduced by the push, whether merged or direct
+        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) {
+            // If we can't get the diff (e.g., first commit on branch), throw a clear error
+            throw new Error(`Could not get diff for default branch '${defaultBranch}'. ` +
+                `This might be the first commit on the branch. Error: ${error.message}`);
+        }
+    }
+    // Scenario 3: Feature Branch Push
+    // When code is pushed to a feature branch, we want to see all changes vs the default branch
+    // Compare: origin/default vs origin/feature-branch
+    // This shows cumulative changes in the feature branch (all commits vs default branch)
+    // Note: We don't use HEAD~1 vs HEAD because that only shows the last commit,
+    //       not the cumulative changes in the branch
+    if (refName) {
+        // For branch pushes, compare against origin/default (detected default branch)
+        // GitHub Actions with fetch-depth: 0 should have origin/default available
+        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
+        };
+    }
+    // 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/repo.js

@@ -1,11 +1,47 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRepoName = getRepoName;
 exports.getBranchName = getBranchName;
+exports.getDefaultBranchName = getDefaultBranchName;
 const simple_git_1 = __importDefault(require("simple-git"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 /**
  * Gets repository URL. Prefers CI environment variables over git commands.
  *
@@ -61,3 +97,46 @@ async function getBranchName(repoRoot) {
         return null;
     }
 }
+/**
+ * Detects the default branch name of the repository for GitHub Actions.
+ *
+ * Uses GITHUB_EVENT_PATH JSON (repository.default_branch) - the most authoritative source
+ * provided directly by GitHub Actions.
+ *
+ * This function is ONLY called from GitHub Actions context (getGitHubDiff),
+ * so GITHUB_EVENT_PATH should always be available. If it's not, we fail with a clear error.
+ *
+ * Returns the branch name (e.g., "main", "master") without the "origin/" prefix.
+ * Throws an error if the default branch cannot be detected.
+ */
+async function getDefaultBranchName(repoRoot) {
+    // GitHub Actions provides GITHUB_EVENT_PATH which contains repository.default_branch
+    const githubEventPath = process.env.GITHUB_EVENT_PATH;
+    if (!githubEventPath) {
+        throw new Error('GITHUB_EVENT_PATH environment variable is not set. ' +
+            'This should be automatically provided by GitHub Actions. ' +
+            'This function should only be called in GitHub Actions context.');
+    }
+    try {
+        const eventPath = path.resolve(githubEventPath);
+        if (!fs.existsSync(eventPath)) {
+            throw new Error(`GITHUB_EVENT_PATH file does not exist: ${eventPath}`);
+        }
+        const eventJson = JSON.parse(fs.readFileSync(eventPath, 'utf8'));
+        const defaultBranch = eventJson.repository?.default_branch;
+        if (!defaultBranch || typeof defaultBranch !== 'string') {
+            throw new Error('Could not find repository.default_branch in GITHUB_EVENT_PATH JSON. ' +
+                'This should be automatically provided by GitHub Actions.');
+        }
+        return defaultBranch;
+    }
+    catch (error) {
+        // If it's already our error, re-throw it
+        if (error.message.includes('GITHUB_EVENT_PATH') || error.message.includes('default_branch')) {
+            throw error;
+        }
+        // Otherwise, wrap it
+        throw new Error(`Failed to read or parse GITHUB_EVENT_PATH: ${error.message}. ` +
+            'This should be automatically provided by GitHub Actions.');
+    }
+}

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

@@ -11,16 +11,20 @@ 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 environment.
  *
  * Each environment has a single, specific implementation:
  * - Vercel: Uses VERCEL_GIT_COMMIT_SHA, gets commit diff via git show
- * - GitHub: Uses branch/PR context with base branch detection
- * - GitLab: Uses branch/MR context with base branch detection
- * - Local: Uses staged/unstaged changes
+ * - 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) {
@@ -28,25 +32,32 @@ async function getDiffForEnvironment(environment, repoRoot, context) {
             // 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':
-            // For other environments, use context-based routing (legacy, will be refactored)
-            if (!context) {
-                throw new Error(`Context required for ${environment} environment`);
-            }
-            return await getDiffForContext(context, repoRoot, environment);
+            // 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}`);
     }
 }
 /**
- * Executes the appropriate git diff function based on context.
+ * Legacy GitLab-specific diff function (deprecated).
  *
- * This is the legacy context-based routing. New code should use getDiffForEnvironment().
- * This function maps context types to their corresponding git diff functions.
+ * 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);
@@ -57,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.20",
+  "version": "0.1.22",
   "description": "Threadline CLI - AI-powered linter based on your natural language documentation",
   "main": "dist/index.js",
   "bin": {