threadlines 0.1.23 → 0.1.24

package/dist/git/context.js

@@ -16,6 +16,8 @@ const repo_2 = require("./repo");
  * Each environment has a single, specific implementation:
  * - GitHub: Uses GITHUB_REPOSITORY, GITHUB_REF_NAME, and GitHub-specific diff logic
  * - Vercel: Uses VERCEL_GIT_REPO_OWNER/SLUG, VERCEL_GIT_COMMIT_REF, and Vercel-specific diff logic
+ * - GitLab: Uses CI_PROJECT_URL, CI_COMMIT_REF_NAME, and GitLab-specific diff logic
+ *           (fetches default branch on-demand since GitLab only clones current branch)
  * - Local: Uses git commands for repo/branch, and local diff logic
  *
  * All methods fail loudly if they can't get the required information.
@@ -41,8 +43,11 @@ async function getGitContextForEnvironment(environment, repoRoot) {
                 branchName: await (0, repo_2.getLocalBranchName)(repoRoot)
             };
         case 'gitlab':
-            // GitLab not implemented yet - will be added later
-            throw new Error('GitLab environment not yet supported for unified git context collection.');
+            return {
+                diff: await (0, git_diff_executor_1.getDiffForEnvironment)('gitlab', repoRoot),
+                repoName: await (0, repo_1.getGitLabRepoName)(repoRoot),
+                branchName: await (0, repo_2.getGitLabBranchName)(repoRoot)
+            };
         default:
             const _exhaustive = environment;
             throw new Error(`Unknown environment: ${_exhaustive}`);

package/dist/git/github-diff.js

@@ -27,7 +27,13 @@ const repo_1 = require("./repo");
  *    Compare: origin/default~1 vs origin/default
  *    Shows: Changes in the direct commit
  *
-  */
+ * Known Limitation - Rebase and Merge:
+ *    When using "Rebase and merge" strategy in GitHub, multiple commits are
+ *    added to the default branch. Our approach (default~1 vs default) only
+ *    captures the LAST commit, not all rebased commits. This is a naive
+ *    implementation. To fully support rebase merges, we'd need to use the
+ *    `before` SHA from GITHUB_EVENT_PATH to compare before...after.
+ */
 async function getGitHubDiff(repoRoot) {
     const git = (0, simple_git_1.default)(repoRoot);
     // Check if we're in a git repo

package/dist/git/gitlab-diff.js

@@ -8,13 +8,21 @@ 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
+ * 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.
  *
- * 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.
+ * 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)
+ *
+ * This is the ONLY implementation for GitLab - no fallbacks, no alternatives.
  */
 async function getGitLabDiff(repoRoot) {
     const git = (0, simple_git_1.default)(repoRoot);
@@ -23,19 +31,23 @@ async function getGitLabDiff(repoRoot) {
     if (!isRepo) {
         throw new Error('Not a git repository. Threadline requires a git repository.');
     }
-    // Determine context from GitLab CI environment variables
+    // 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;
-    // MR context: GitLab provides both target and source branches
+    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.');
         }
-        // Use the branches GitLab provides directly - no detection needed
+        // Fetch target branch (GitLab doesn't have it by default)
+        console.log(`  [GitLab] Fetching target branch: origin/${targetBranch}`);
+        await git.fetch(['origin', `${targetBranch}:refs/remotes/origin/${targetBranch}`, '--depth=1']);
+        // Diff target vs source
         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);
@@ -44,20 +56,31 @@ async function getGitLabDiff(repoRoot) {
             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}`]);
+    // Scenario 2 & 3: Branch Push
+    if (!refName) {
+        throw new Error('GitLab CI environment detected but CI_COMMIT_REF_NAME is not set. ' +
+            'This should be automatically provided by GitLab CI.');
+    }
+    // Scenario 3: Default Branch Push (e.g., direct commit to main)
+    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
         };
     }
-    // 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.');
+    // 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']);
+    // Diff default vs feature
+    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
+    };
 }

package/dist/git/repo.js

@@ -42,6 +42,8 @@ exports.getLocalRepoName = getLocalRepoName;
 exports.getGitHubBranchName = getGitHubBranchName;
 exports.getVercelBranchName = getVercelBranchName;
 exports.getLocalBranchName = getLocalBranchName;
+exports.getGitLabRepoName = getGitLabRepoName;
+exports.getGitLabBranchName = getGitLabBranchName;
 exports.getDefaultBranchName = getDefaultBranchName;
 const simple_git_1 = __importDefault(require("simple-git"));
 const fs = __importStar(require("fs"));
@@ -173,6 +175,36 @@ async function getLocalBranchName(repoRoot) {
         throw new Error(`Local: Failed to get branch name from git: ${error.message}`);
     }
 }
+/**
+ * GitLab CI: Get repository name
+ *
+ * Uses CI_PROJECT_URL environment variable.
+ * This is the ONLY method for GitLab - no fallbacks, no alternatives.
+ */
+async function getGitLabRepoName(repoRoot) {
+    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.');
+    }
+    // CI_PROJECT_URL is like "https://gitlab.com/owner/repo"
+    // Add .git suffix for consistency with other environments
+    return `${projectUrl}.git`;
+}
+/**
+ * GitLab CI: Get branch name
+ *
+ * Uses CI_COMMIT_REF_NAME environment variable.
+ * This is the ONLY method for GitLab - no fallbacks, no alternatives.
+ */
+async function getGitLabBranchName(repoRoot) {
+    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 the default branch name of the repository for GitHub Actions.
  *

package/package.json

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