threadlines 0.1.21 → 0.1.23

package/dist/commands/check.js

@@ -39,13 +39,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkCommand = checkCommand;
 const experts_1 = require("../validators/experts");
 const file_1 = require("../git/file");
-const repo_1 = require("../git/repo");
 const client_1 = require("../api/client");
 const config_1 = require("../utils/config");
 const environment_1 = require("../utils/environment");
 const context_1 = require("../utils/context");
 const metadata_1 = require("../utils/metadata");
 const git_diff_executor_1 = require("../utils/git-diff-executor");
+const context_2 = require("../git/context");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
@@ -92,6 +92,8 @@ async function checkCommand(options) {
         const environment = (0, environment_1.detectEnvironment)();
         let context;
         let gitDiff;
+        let repoName;
+        let branchName;
         // Validate mutually exclusive flags
         const explicitFlags = [options.branch, options.commit, options.file, options.folder, options.files].filter(Boolean);
         if (explicitFlags.length > 1) {
@@ -104,37 +106,52 @@ async function checkCommand(options) {
             console.log(chalk_1.default.gray(`📝 Reading file: ${options.file}...`));
             gitDiff = await (0, file_1.getFileContent)(repoRoot, options.file);
             context = { type: 'local' }; // File context doesn't need git context
+            // For file/folder/files, repo/branch are not available - skip them
         }
         else if (options.folder) {
             console.log(chalk_1.default.gray(`📝 Reading folder: ${options.folder}...`));
             gitDiff = await (0, file_1.getFolderContent)(repoRoot, options.folder);
             context = { type: 'local' };
+            // For file/folder/files, repo/branch are not available - skip them
         }
         else if (options.files && options.files.length > 0) {
             console.log(chalk_1.default.gray(`📝 Reading ${options.files.length} file(s)...`));
             gitDiff = await (0, file_1.getMultipleFilesContent)(repoRoot, options.files);
             context = { type: 'local' };
+            // For file/folder/files, repo/branch are not available - skip them
         }
         else if (options.branch) {
             console.log(chalk_1.default.gray(`📝 Collecting git changes for branch: ${options.branch}...`));
             context = { type: 'branch', branchName: options.branch };
             gitDiff = await (0, git_diff_executor_1.getDiffForContext)(context, repoRoot, environment);
+            // Get repo/branch using unified approach
+            const gitContext = await (0, context_2.getGitContextForEnvironment)(environment, repoRoot);
+            repoName = gitContext.repoName;
+            branchName = gitContext.branchName;
         }
         else if (options.commit) {
             console.log(chalk_1.default.gray(`📝 Collecting git changes for commit: ${options.commit}...`));
             context = { type: 'commit', commitSha: options.commit };
             gitDiff = await (0, git_diff_executor_1.getDiffForContext)(context, repoRoot, environment);
+            // Get repo/branch using unified approach
+            const gitContext = await (0, context_2.getGitContextForEnvironment)(environment, repoRoot);
+            repoName = gitContext.repoName;
+            branchName = gitContext.branchName;
         }
         else {
-            // Auto-detect: Use environment-specific implementation
+            // Auto-detect: Use unified git context collection
             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);
+            console.log(chalk_1.default.gray(`📝 Collecting git context for ${envNames[environment]}...`));
+            // Use unified git context collection (diff + repo + branch)
+            const gitContext = await (0, context_2.getGitContextForEnvironment)(environment, repoRoot);
+            gitDiff = gitContext.diff;
+            repoName = gitContext.repoName;
+            branchName = gitContext.branchName;
             // Create context for metadata collection
             if (environment === 'vercel') {
                 context = { type: 'commit', commitSha: process.env.VERCEL_GIT_COMMIT_SHA };
@@ -151,8 +168,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() === '') {
@@ -166,7 +185,7 @@ async function checkCommand(options) {
             process.exit(0);
         }
         console.log(chalk_1.default.green(`✓ Found ${gitDiff.changedFiles.length} changed file(s)\n`));
-        // 3. Read context files for each threadline
+        // 4. Read context files for each threadline
         const threadlinesWithContext = threadlines.map(threadline => {
             const contextContent = {};
             if (threadline.contextFiles) {
@@ -186,9 +205,6 @@ async function checkCommand(options) {
                 contextContent
             };
         });
-        // 4. Get repo name and branch name
-        const repoName = await (0, repo_1.getRepoName)(repoRoot);
-        const branchName = await (0, repo_1.getBranchName)(repoRoot);
         // 5. Get API URL
         const apiUrl = options.apiUrl ||
             process.env.THREADLINE_API_URL ||
@@ -202,8 +218,8 @@ async function checkCommand(options) {
             files: gitDiff.changedFiles,
             apiKey,
             account,
-            repoName: repoName || undefined,
-            branchName: branchName || undefined,
+            repoName: repoName,
+            branchName: branchName,
             commitSha: metadata.commitSha,
             commitMessage: metadata.commitMessage,
             prTitle: metadata.prTitle,

package/dist/git/context.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Unified Git Context Collection
+ *
+ * Collects all git-related information (diff, repo name, branch name) in a unified way.
+ * Each environment has isolated implementations - changes to one don't affect others.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitContextForEnvironment = getGitContextForEnvironment;
+const git_diff_executor_1 = require("../utils/git-diff-executor");
+const repo_1 = require("./repo");
+const repo_2 = require("./repo");
+/**
+ * Collects all git context (diff, repo name, branch name) for the given environment.
+ *
+ * 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
+ * - Local: Uses git commands for repo/branch, and local diff logic
+ *
+ * All methods fail loudly if they can't get the required information.
+ */
+async function getGitContextForEnvironment(environment, repoRoot) {
+    switch (environment) {
+        case 'github':
+            return {
+                diff: await (0, git_diff_executor_1.getDiffForEnvironment)('github', repoRoot),
+                repoName: await (0, repo_1.getGitHubRepoName)(repoRoot),
+                branchName: await (0, repo_2.getGitHubBranchName)(repoRoot)
+            };
+        case 'vercel':
+            return {
+                diff: await (0, git_diff_executor_1.getDiffForEnvironment)('vercel', repoRoot),
+                repoName: await (0, repo_1.getVercelRepoName)(repoRoot),
+                branchName: await (0, repo_2.getVercelBranchName)(repoRoot)
+            };
+        case 'local':
+            return {
+                diff: await (0, git_diff_executor_1.getDiffForEnvironment)('local', repoRoot),
+                repoName: await (0, repo_1.getLocalRepoName)(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.');
+        default:
+            const _exhaustive = environment;
+            throw new Error(`Unknown environment: ${_exhaustive}`);
+    }
+}

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,63 +1,218 @@
 "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.getGitHubRepoName = getGitHubRepoName;
+exports.getVercelRepoName = getVercelRepoName;
+exports.getLocalRepoName = getLocalRepoName;
+exports.getGitHubBranchName = getGitHubBranchName;
+exports.getVercelBranchName = getVercelBranchName;
+exports.getLocalBranchName = getLocalBranchName;
+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.
+ * GitHub Actions: Get repository name
  *
- * CI Environment Variables:
- * - GitHub Actions: GITHUB_REPOSITORY (format: "owner/repo"), GITHUB_SERVER_URL
- * - Vercel: VERCEL_GIT_REPO_OWNER, VERCEL_GIT_REPO_SLUG
- * - GitLab CI: Not available (falls back to git)
- * - Local: Falls back to git origin remote
+ * Uses GITHUB_REPOSITORY environment variable (format: "owner/repo").
+ * This is the ONLY method for GitHub - no fallbacks, no alternatives.
  */
-async function getRepoName(repoRoot) {
-    // GitHub Actions: GITHUB_REPOSITORY = "owner/repo"
-    if (process.env.GITHUB_REPOSITORY) {
-        const serverUrl = process.env.GITHUB_SERVER_URL || 'https://github.com';
-        return `${serverUrl}/${process.env.GITHUB_REPOSITORY}.git`;
+async function getGitHubRepoName(repoRoot) {
+    const githubRepo = process.env.GITHUB_REPOSITORY;
+    if (!githubRepo) {
+        throw new Error('GitHub Actions: GITHUB_REPOSITORY environment variable is not set. ' +
+            'This should be automatically provided by GitHub Actions.');
     }
-    // Vercel: Construct from owner + slug
-    if (process.env.VERCEL_GIT_REPO_OWNER && process.env.VERCEL_GIT_REPO_SLUG) {
-        return `https://github.com/${process.env.VERCEL_GIT_REPO_OWNER}/${process.env.VERCEL_GIT_REPO_SLUG}.git`;
+    const serverUrl = process.env.GITHUB_SERVER_URL || 'https://github.com';
+    return `${serverUrl}/${githubRepo}.git`;
+}
+/**
+ * Vercel: Get repository name
+ *
+ * Uses VERCEL_GIT_REPO_OWNER and VERCEL_GIT_REPO_SLUG environment variables.
+ * This is the ONLY method for Vercel - no fallbacks, no alternatives.
+ */
+async function getVercelRepoName(repoRoot) {
+    const owner = process.env.VERCEL_GIT_REPO_OWNER;
+    const slug = process.env.VERCEL_GIT_REPO_SLUG;
+    if (!owner || !slug) {
+        throw new Error('Vercel: VERCEL_GIT_REPO_OWNER or VERCEL_GIT_REPO_SLUG environment variable is not set. ' +
+            'This should be automatically provided by Vercel CI.');
     }
-    // Fallback: git origin remote (local dev, GitLab CI)
+    return `https://github.com/${owner}/${slug}.git`;
+}
+/**
+ * Local: Get repository name
+ *
+ * Uses git command to get origin remote URL.
+ * This is the ONLY method for local - no fallbacks, no alternatives.
+ * Git should always be available in local development.
+ */
+async function getLocalRepoName(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('Local: Not a git repository. Threadline requires a git repository.');
+    }
     try {
         const remotes = await git.getRemotes(true);
         const origin = remotes.find(r => r.name === 'origin');
-        return origin?.refs?.fetch || null;
+        if (!origin || !origin.refs?.fetch) {
+            throw new Error('Local: No origin remote found. ' +
+                'Please configure an origin remote: git remote add origin <url>');
+        }
+        return origin.refs.fetch;
     }
-    catch {
-        return null;
+    catch (error) {
+        // If it's already our error, re-throw it
+        if (error.message.includes('Local:')) {
+            throw error;
+        }
+        // Otherwise, wrap it
+        throw new Error(`Local: Failed to get repository name from git: ${error.message}`);
+    }
+}
+/**
+ * GitHub Actions: Get branch name
+ *
+ * Uses GITHUB_REF_NAME environment variable.
+ * This is the ONLY method for GitHub - no fallbacks, no alternatives.
+ */
+async function getGitHubBranchName(repoRoot) {
+    const refName = process.env.GITHUB_REF_NAME;
+    if (!refName) {
+        throw new Error('GitHub Actions: GITHUB_REF_NAME environment variable is not set. ' +
+            'This should be automatically provided by GitHub Actions.');
     }
+    return refName;
 }
 /**
- * Gets branch name. Prefers CI environment variables over git commands.
+ * Vercel: Get branch name
  *
- * CI Environment Variables:
- * - GitHub Actions: GITHUB_REF_NAME
- * - Vercel: VERCEL_GIT_COMMIT_REF
- * - GitLab CI: CI_COMMIT_REF_NAME
- * - Local: Falls back to git revparse --abbrev-ref HEAD
+ * Uses VERCEL_GIT_COMMIT_REF environment variable.
+ * This is the ONLY method for Vercel - no fallbacks, no alternatives.
  */
-async function getBranchName(repoRoot) {
-    if (process.env.GITHUB_REF_NAME)
-        return process.env.GITHUB_REF_NAME;
-    if (process.env.VERCEL_GIT_COMMIT_REF)
-        return process.env.VERCEL_GIT_COMMIT_REF;
-    if (process.env.CI_COMMIT_REF_NAME)
-        return process.env.CI_COMMIT_REF_NAME;
-    // Fallback: git command
+async function getVercelBranchName(repoRoot) {
+    const branchName = process.env.VERCEL_GIT_COMMIT_REF;
+    if (!branchName) {
+        throw new Error('Vercel: VERCEL_GIT_COMMIT_REF environment variable is not set. ' +
+            'This should be automatically provided by Vercel CI.');
+    }
+    return branchName;
+}
+/**
+ * Local: Get branch name
+ *
+ * Uses git command to get current branch name.
+ * This is the ONLY method for local - no fallbacks, no alternatives.
+ * Git should always be available in local development.
+ */
+async function getLocalBranchName(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('Local: Not a git repository. Threadline requires a git repository.');
+    }
+    try {
+        const branchName = await git.revparse(['--abbrev-ref', 'HEAD']);
+        if (!branchName || branchName.trim() === '') {
+            throw new Error('Local: Could not determine branch name. ' +
+                'This might be a brand new repository with no commits. ' +
+                'Make at least one commit before running threadlines check.');
+        }
+        // Handle detached HEAD state
+        if (branchName === 'HEAD') {
+            throw new Error('Local: Currently in detached HEAD state. ' +
+                'Please checkout a branch before running threadlines check.');
+        }
+        return branchName.trim();
+    }
+    catch (error) {
+        // If it's already our error, re-throw it
+        if (error.message.includes('Local:')) {
+            throw error;
+        }
+        // Otherwise, wrap it
+        throw new Error(`Local: Failed to get branch name from git: ${error.message}`);
+    }
+}
+/**
+ * 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 {
-        return await git.revparse(['--abbrev-ref', 'HEAD']) || null;
+        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 {
-        return null;
+    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.23",
   "description": "Threadline CLI - AI-powered linter based on your natural language documentation",
   "main": "dist/index.js",
   "bin": {