threadlines 0.1.21 → 0.1.22

package/dist/commands/check.js

@@ -151,8 +151,10 @@ async function checkCommand(options) {
         // 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/github-diff.js

@@ -5,16 +5,29 @@ var __importDefault = (this && this.__importDefault) || function (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
  *
- * 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
+ * Handles four scenarios:
  *
- * This is the ONLY implementation for GitHub - no fallbacks, no alternatives.
- * If this doesn't work, we fail with a clear error.
- */
+ * 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
@@ -22,18 +35,25 @@ async function getGitHubDiff(repoRoot) {
     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;
-    // PR context: GitHub provides both base and head branches
+    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.');
         }
-        // Use the branches GitHub provides directly - no detection needed
+        // 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);
@@ -42,12 +62,40 @@ async function getGitHubDiff(repoRoot) {
             changedFiles
         };
     }
-    // Branch context: GitHub provides branch name, compare against origin/main
+    // 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/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}`]);
+        // 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 || '',

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/package.json

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