threadlines 0.1.20 → 0.1.21

package/dist/commands/check.js

@@ -127,19 +127,25 @@ 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)

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,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/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.21",
   "description": "Threadline CLI - AI-powered linter based on your natural language documentation",
   "main": "dist/index.js",
   "bin": {