threadlines 0.1.18 → 0.1.20

package/dist/commands/check.js

@@ -126,11 +126,21 @@ 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
+            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)
+                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);
+            }
         }
         // 3. Collect metadata (commit SHA, commit message, PR title)
         const metadata = await (0, metadata_1.collectMetadata)(context, environment, repoRoot);

package/dist/git/diff.js

@@ -96,8 +96,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 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}`]);
@@ -156,15 +157,15 @@ async function getBranchDiff(repoRoot, branchName, baseBranch) {
         catch (error) {
             console.log(`[DEBUG] Default branch (refs/remotes/origin/HEAD) not configured: ${error.message || 'not found'}`);
         }
-        // Strategy 3: Try common branch names by checking remote refs first (most reliable fallback)
+        // Strategy 3: Try common branch names by checking remote refs first, then local branches
         // This works reliably in CI with fetch-depth: 0, and also works locally
         const commonBases = ['main', 'master', 'develop'];
         for (const candidate of commonBases) {
             if (candidate.toLowerCase() === branchName.toLowerCase()) {
                 continue; // Skip if it's the same branch
             }
+            // Try remote ref first
             try {
-                // Always check remote ref first (this is reliable in CI with fetch-depth: 0)
                 await git.revparse([`origin/${candidate}`]);
                 // In CI, prefer remote refs since local branches often don't exist
                 if (isCI) {
@@ -184,7 +185,16 @@ async function getBranchDiff(repoRoot, branchName, baseBranch) {
             }
             catch (error) {
                 console.log(`[DEBUG] Remote branch 'origin/${candidate}' not found: ${error.message || 'does not exist'}`);
-                // Continue to next candidate
+                // If remote doesn't exist, also try local branch (especially for CI like Vercel)
+                try {
+                    await git.revparse([candidate]);
+                    console.log(`[DEBUG] Remote 'origin/${candidate}' not available, but local branch '${candidate}' found - using local`);
+                    return candidate;
+                }
+                catch (localError) {
+                    console.log(`[DEBUG] Local branch '${candidate}' also not found: ${localError.message || 'does not exist'}`);
+                    // Continue to next candidate
+                }
             }
         }
         // All strategies failed - provide clear error with context

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,19 +2,49 @@
 /**
  * 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");
+/**
+ * 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
+ *
+ * No fallbacks - if the environment-specific implementation fails, we fail clearly.
+ */
+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':
+        case 'gitlab':
+        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);
+        default:
+            const _exhaustive = environment;
+            throw new Error(`Unknown environment: ${_exhaustive}`);
+    }
+}
 /**
  * Executes the appropriate git diff function based on context.
  *
+ * This is the legacy context-based routing. New code should use getDiffForEnvironment().
  * This function maps context types to their corresponding git diff functions.
- * The actual git diff functions handle environment-specific details internally.
  */
 async function getDiffForContext(context, repoRoot, environment) {
     switch (context.type) {

package/package.json

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