threadlines 0.1.6 → 0.1.8

package/dist/commands/check.js

@@ -39,6 +39,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkCommand = checkCommand;
 const experts_1 = require("../validators/experts");
 const diff_1 = require("../git/diff");
+const file_1 = require("../git/file");
+const repo_1 = require("../git/repo");
+const ci_detection_1 = require("../utils/ci-detection");
 const client_1 = require("../api/client");
 const config_1 = require("../utils/config");
 const fs = __importStar(require("fs"));
@@ -60,6 +63,19 @@ async function checkCommand(options) {
         console.log(chalk_1.default.gray('For CI/CD: Set THREADLINE_API_KEY as an environment variable in your platform settings.'));
         process.exit(1);
     }
+    // Get and validate account key
+    const account = (0, config_1.getThreadlineAccount)();
+    if (!account) {
+        console.error(chalk_1.default.red('❌ Error: THREADLINE_ACCOUNT is required'));
+        console.log('');
+        console.log(chalk_1.default.yellow('To fix this:'));
+        console.log(chalk_1.default.white('  1. Create a .env.local file in your project root'));
+        console.log(chalk_1.default.gray('  2. Add: THREADLINE_ACCOUNT=your-email@example.com'));
+        console.log(chalk_1.default.gray('  3. Make sure .env.local is in your .gitignore'));
+        console.log('');
+        console.log(chalk_1.default.gray('For CI/CD: Set THREADLINE_ACCOUNT as an environment variable in your platform settings.'));
+        process.exit(1);
+    }
     try {
         // 1. Find and validate threadlines
         console.log(chalk_1.default.gray('📋 Finding threadlines...'));
@@ -70,9 +86,76 @@ async function checkCommand(options) {
             console.log(chalk_1.default.gray('   Run `npx threadlines init` to create your first threadline.'));
             process.exit(0);
         }
-        // 2. Get git diff
-        console.log(chalk_1.default.gray('📝 Collecting git changes...'));
-        const gitDiff = await (0, diff_1.getGitDiff)(repoRoot);
+        // 2. Determine review target and get git diff
+        let gitDiff;
+        let reviewContext = { type: 'local' };
+        // Validate mutually exclusive flags
+        const explicitFlags = [options.branch, options.commit, options.file, options.folder, options.files].filter(Boolean);
+        if (explicitFlags.length > 1) {
+            console.error(chalk_1.default.red('❌ Error: Only one review option can be specified at a time'));
+            console.log(chalk_1.default.gray('   Options: --branch, --commit, --file, --folder, --files'));
+            process.exit(1);
+        }
+        // Check for explicit flags first (override auto-detection)
+        if (options.file) {
+            console.log(chalk_1.default.gray(`📝 Reading file: ${options.file}...`));
+            gitDiff = await (0, file_1.getFileContent)(repoRoot, options.file);
+            reviewContext = { type: 'file', value: options.file };
+        }
+        else if (options.folder) {
+            console.log(chalk_1.default.gray(`📝 Reading folder: ${options.folder}...`));
+            gitDiff = await (0, file_1.getFolderContent)(repoRoot, options.folder);
+            reviewContext = { type: 'folder', value: options.folder };
+        }
+        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);
+            reviewContext = { type: 'files', value: options.files.join(', ') };
+        }
+        else if (options.branch) {
+            console.log(chalk_1.default.gray(`📝 Collecting git changes for branch: ${options.branch}...`));
+            gitDiff = await (0, diff_1.getBranchDiff)(repoRoot, options.branch);
+            reviewContext = { type: 'branch', value: options.branch };
+        }
+        else if (options.commit) {
+            console.log(chalk_1.default.gray(`📝 Collecting git changes for commit: ${options.commit}...`));
+            gitDiff = await (0, diff_1.getCommitDiff)(repoRoot, options.commit);
+            reviewContext = { type: 'commit', value: options.commit };
+        }
+        else {
+            // Auto-detect CI environment or use local changes
+            const autoTarget = (0, ci_detection_1.getAutoReviewTarget)();
+            if (autoTarget) {
+                if (autoTarget.type === 'pr' || autoTarget.type === 'mr') {
+                    // PR/MR: use source and target branches
+                    console.log(chalk_1.default.gray(`📝 Collecting git changes for ${autoTarget.type.toUpperCase()}: ${autoTarget.value}...`));
+                    gitDiff = await (0, diff_1.getPRMRDiff)(repoRoot, autoTarget.sourceBranch, autoTarget.targetBranch);
+                    reviewContext = { type: autoTarget.type, value: autoTarget.value };
+                }
+                else if (autoTarget.type === 'branch') {
+                    // Branch: use branch vs base
+                    console.log(chalk_1.default.gray(`📝 Collecting git changes for branch: ${autoTarget.value}...`));
+                    gitDiff = await (0, diff_1.getBranchDiff)(repoRoot, autoTarget.value);
+                    reviewContext = { type: 'branch', value: autoTarget.value };
+                }
+                else if (autoTarget.type === 'commit') {
+                    // Commit: use single commit
+                    console.log(chalk_1.default.gray(`📝 Collecting git changes for commit: ${autoTarget.value}...`));
+                    gitDiff = await (0, diff_1.getCommitDiff)(repoRoot, autoTarget.value);
+                    reviewContext = { type: 'commit', value: autoTarget.value };
+                }
+                else {
+                    // Fallback: local development
+                    console.log(chalk_1.default.gray('📝 Collecting git changes...'));
+                    gitDiff = await (0, diff_1.getGitDiff)(repoRoot);
+                }
+            }
+            else {
+                // Local development: use staged/unstaged changes
+                console.log(chalk_1.default.gray('📝 Collecting git changes...'));
+                gitDiff = await (0, diff_1.getGitDiff)(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);
@@ -109,19 +192,28 @@ async function checkCommand(options) {
                 contextContent
             };
         });
-        // 4. Get API URL
-        const apiUrl = options.apiUrl || process.env.THREADLINE_API_URL || 'http://localhost:3000';
-        // 5. Call review API
+        // 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 (auto-detect Vercel if available)
+        const apiUrl = options.apiUrl ||
+            process.env.THREADLINE_API_URL ||
+            (process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}` : null) ||
+            'http://localhost:3000';
+        // 6. Call review API
         console.log(chalk_1.default.gray('🤖 Running threadline checks...'));
         const client = new client_1.ReviewAPIClient(apiUrl);
         const response = await client.review({
             threadlines: threadlinesWithContext,
             diff: gitDiff.diff,
             files: gitDiff.changedFiles,
-            apiKey
+            apiKey,
+            account,
+            repoName: repoName || undefined,
+            branchName: branchName || undefined
         });
-        // 6. Display results
-        displayResults(response);
+        // 7. Display results (with filtering if --full not specified)
+        displayResults(response, options.full || false);
         // Exit with appropriate code
         const hasAttention = response.results.some(r => r.status === 'attention');
         process.exit(hasAttention ? 1 : 0);
@@ -131,8 +223,12 @@ async function checkCommand(options) {
         process.exit(1);
     }
 }
-function displayResults(response) {
+function displayResults(response, showFull) {
     const { results, metadata, message } = response;
+    // Filter results based on --full flag
+    const filteredResults = showFull
+        ? results
+        : results.filter((r) => r.status === 'attention');
     // Display informational message if present (e.g., zero diffs)
     if (message) {
         console.log('\n' + chalk_1.default.blue('ℹ️  ' + message));
@@ -142,14 +238,23 @@ function displayResults(response) {
     const notRelevant = results.filter((r) => r.status === 'not_relevant').length;
     const compliant = results.filter((r) => r.status === 'compliant').length;
     const attention = results.filter((r) => r.status === 'attention').length;
-    if (notRelevant > 0) {
-        console.log(chalk_1.default.gray(`  ${notRelevant} not relevant`));
-    }
-    if (compliant > 0) {
-        console.log(chalk_1.default.green(`  ${compliant} compliant`));
+    if (showFull) {
+        // Show all results when --full flag is used
+        if (notRelevant > 0) {
+            console.log(chalk_1.default.gray(`  ${notRelevant} not relevant`));
+        }
+        if (compliant > 0) {
+            console.log(chalk_1.default.green(`  ${compliant} compliant`));
+        }
+        if (attention > 0) {
+            console.log(chalk_1.default.yellow(`  ${attention} attention`));
+        }
     }
-    if (attention > 0) {
-        console.log(chalk_1.default.yellow(`  ${attention} attention`));
+    else {
+        // Default: only show attention items
+        if (attention > 0) {
+            console.log(chalk_1.default.yellow(`  ${attention} attention`));
+        }
     }
     if (metadata.timedOut > 0) {
         console.log(chalk_1.default.yellow(`  ${metadata.timedOut} timed out`));
@@ -159,7 +264,7 @@ function displayResults(response) {
     }
     console.log('');
     // Show attention items
-    const attentionItems = results.filter((r) => r.status === 'attention');
+    const attentionItems = filteredResults.filter((r) => r.status === 'attention');
     if (attentionItems.length > 0) {
         for (const item of attentionItems) {
             console.log(chalk_1.default.yellow(`⚠️  ${item.expertId}`));
@@ -176,8 +281,15 @@ function displayResults(response) {
         }
         console.log('');
     }
-    // Show compliant items (optional, can be verbose)
-    if (attentionItems.length === 0 && compliant > 0) {
+    // Show compliant items (only when --full flag is used)
+    if (showFull) {
+        const compliantItems = filteredResults.filter((r) => r.status === 'compliant');
+        if (compliantItems.length > 0 && attentionItems.length === 0) {
+            console.log(chalk_1.default.green('✓ All threadlines passed!\n'));
+        }
+    }
+    else if (attentionItems.length === 0 && compliant > 0) {
+        // Default: show success message if no attention items
         console.log(chalk_1.default.green('✓ All threadlines passed!\n'));
     }
 }

package/dist/commands/init.js

@@ -95,11 +95,12 @@ async function initCommand() {
         console.log(chalk_1.default.gray('  1. Edit threadlines/example.md with your coding standards'));
         console.log(chalk_1.default.gray('  2. Rename it to something descriptive (e.g., error-handling.md)'));
         console.log('');
-        console.log(chalk_1.default.yellow('⚠️  IMPORTANT: API Key Setup Required'));
-        console.log(chalk_1.default.white('   To use threadlines check, you need a THREADLINE_API_KEY.'));
+        console.log(chalk_1.default.yellow('⚠️  IMPORTANT: Configuration Required'));
+        console.log(chalk_1.default.white('   To use threadlines check, you need:'));
         console.log('');
         console.log(chalk_1.default.white('   Create a .env.local file in your project root with:'));
         console.log(chalk_1.default.gray('     THREADLINE_API_KEY=your-api-key-here'));
+        console.log(chalk_1.default.gray('     THREADLINE_ACCOUNT=your-email@example.com'));
         console.log('');
         console.log(chalk_1.default.white('   Make sure .env.local is in your .gitignore file!'));
         console.log('');

package/dist/git/diff.js

@@ -4,7 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGitDiff = getGitDiff;
+exports.getBranchDiff = getBranchDiff;
+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
@@ -39,3 +45,164 @@ async function getGitDiff(repoRoot) {
         changedFiles
     };
 }
+/**
+ * Get diff for a specific branch (all commits vs base branch)
+ * Uses git merge-base to find common ancestor, then diffs from there
+ */
+async function getBranchDiff(repoRoot, branchName, baseBranch) {
+    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 base branch
+    let base;
+    if (baseBranch) {
+        // Use provided base branch
+        base = baseBranch;
+    }
+    else {
+        // Check if the branch itself is a base branch (main/master)
+        const baseBranchNames = ['main', 'master'];
+        const isBaseBranch = baseBranchNames.includes(branchName.toLowerCase());
+        if (isBaseBranch) {
+            // For main/master branch, compare against previous commit (HEAD~1)
+            // This checks what changed in the most recent commit
+            try {
+                const previousCommit = await git.revparse(['HEAD~1']).catch(() => null);
+                if (previousCommit) {
+                    // Use commit-based diff instead
+                    const diff = await git.diff([`${previousCommit}..HEAD`]);
+                    const diffSummary = await git.diffSummary([`${previousCommit}..HEAD`]);
+                    const changedFiles = diffSummary.files.map(f => f.file);
+                    return {
+                        diff: diff || '',
+                        changedFiles
+                    };
+                }
+            }
+            catch {
+                // If no previous commit, return empty (first commit)
+                return {
+                    diff: '',
+                    changedFiles: []
+                };
+            }
+        }
+        // Try to detect base branch: upstream, default branch, or common names
+        base = await detectBaseBranch(git, branchName);
+    }
+    // Helper function to detect base branch
+    async function detectBaseBranch(git, branchName) {
+        // Try upstream tracking branch
+        const upstream = await git.revparse(['--abbrev-ref', '--symbolic-full-name', `${branchName}@{u}`]).catch(() => null);
+        if (upstream) {
+            // Extract base from upstream (e.g., "origin/main" -> "main")
+            const upstreamBranch = upstream.replace(/^origin\//, '');
+            // Don't use the branch itself as its base
+            if (upstreamBranch !== branchName) {
+                return upstreamBranch;
+            }
+        }
+        // Try default branch
+        try {
+            const defaultBranch = await git.revparse(['--abbrev-ref', 'refs/remotes/origin/HEAD']);
+            const defaultBranchName = defaultBranch.replace(/^origin\//, '');
+            // Don't use the branch itself as its base
+            if (defaultBranchName !== branchName) {
+                return defaultBranchName;
+            }
+        }
+        catch {
+            // Continue to fallback
+        }
+        // Fallback to common names (excluding the branch itself)
+        const commonBases = ['main', 'master', 'develop'];
+        for (const candidate of commonBases) {
+            if (candidate.toLowerCase() === branchName.toLowerCase()) {
+                continue; // Skip if it's the same branch
+            }
+            try {
+                await git.revparse([`origin/${candidate}`]);
+                return candidate;
+            }
+            catch {
+                // Try next
+            }
+        }
+        throw new Error(`Could not determine base branch for '${branchName}'. Please specify with --base flag or set upstream tracking.`);
+    }
+    // Get diff between base and branch (cumulative diff of all commits)
+    // Format: git diff base...branch (three-dot notation finds common ancestor)
+    const diff = await git.diff([`${base}...${branchName}`]);
+    // Get list of changed files
+    const diffSummary = await git.diffSummary([`${base}...${branchName}`]);
+    const changedFiles = diffSummary.files.map(f => f.file);
+    return {
+        diff: diff || '',
+        changedFiles
+    };
+}
+/**
+ * Get diff for a specific commit
+ */
+async function getCommitDiff(repoRoot, sha) {
+    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 for the commit
+    // Use git show to get the commit diff
+    let diff;
+    let changedFiles;
+    try {
+        // Get diff using git show
+        diff = await git.show([sha, '--format=', '--no-color']);
+        // Get changed files using git show --name-only
+        const commitFiles = await git.show([sha, '--name-only', '--format=', '--pretty=format:']);
+        changedFiles = commitFiles
+            .split('\n')
+            .filter(line => line.trim().length > 0)
+            .map(line => line.trim());
+    }
+    catch (error) {
+        // Fallback: try git diff format
+        try {
+            diff = await git.diff([`${sha}^..${sha}`]);
+            // Get files from diff summary
+            const diffSummary = await git.diffSummary([`${sha}^..${sha}`]);
+            changedFiles = diffSummary.files.map(f => f.file);
+        }
+        catch (diffError) {
+            throw new Error(`Commit ${sha} not found or invalid: ${error.message || diffError.message}`);
+        }
+    }
+    return {
+        diff: diff || '',
+        changedFiles
+    };
+}
+/**
+ * Get diff for PR/MR (source branch vs target branch)
+ */
+async function getPRMRDiff(repoRoot, sourceBranch, targetBranch) {
+    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 between target and source (cumulative diff)
+    // Format: git diff target...source (three-dot notation finds common ancestor)
+    const diff = await git.diff([`${targetBranch}...${sourceBranch}`]);
+    // Get list of changed files
+    const diffSummary = await git.diffSummary([`${targetBranch}...${sourceBranch}`]);
+    const changedFiles = diffSummary.files.map(f => f.file);
+    return {
+        diff: diff || '',
+        changedFiles
+    };
+}

package/dist/git/file.js

@@ -0,0 +1,159 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileContent = getFileContent;
+exports.getFolderContent = getFolderContent;
+exports.getMultipleFilesContent = getMultipleFilesContent;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob_1 = require("glob");
+/**
+ * Read content of a single file and create artificial diff (all lines as additions)
+ */
+async function getFileContent(repoRoot, filePath) {
+    const fullPath = path.resolve(repoRoot, filePath);
+    // Check if file exists
+    if (!fs.existsSync(fullPath)) {
+        throw new Error(`File '${filePath}' not found`);
+    }
+    // Check if it's actually a file (not a directory)
+    const stats = fs.statSync(fullPath);
+    if (!stats.isFile()) {
+        throw new Error(`Path '${filePath}' is not a file`);
+    }
+    // Read file content
+    const content = fs.readFileSync(fullPath, 'utf-8');
+    // Create artificial diff (all lines as additions)
+    const lines = content.split('\n');
+    const diff = lines.map((line, index) => `+${line}`).join('\n');
+    // Add diff header
+    const diffHeader = `--- /dev/null\n+++ ${filePath}\n@@ -0,0 +1,${lines.length} @@\n`;
+    const fullDiff = diffHeader + diff;
+    return {
+        diff: fullDiff,
+        changedFiles: [filePath]
+    };
+}
+/**
+ * Read content of all files in a folder (recursively) and create artificial diff
+ */
+async function getFolderContent(repoRoot, folderPath) {
+    const fullPath = path.resolve(repoRoot, folderPath);
+    // Check if folder exists
+    if (!fs.existsSync(fullPath)) {
+        throw new Error(`Folder '${folderPath}' not found`);
+    }
+    // Check if it's actually a directory
+    const stats = fs.statSync(fullPath);
+    if (!stats.isDirectory()) {
+        throw new Error(`Path '${folderPath}' is not a folder`);
+    }
+    // Find all files recursively
+    const pattern = path.join(fullPath, '**', '*');
+    const files = await (0, glob_1.glob)(pattern, {
+        cwd: repoRoot,
+        absolute: false,
+        ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**']
+    });
+    // Filter to only actual files (not directories)
+    const filePaths = files.filter(file => {
+        const fileFullPath = path.resolve(repoRoot, file);
+        try {
+            return fs.statSync(fileFullPath).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+    if (filePaths.length === 0) {
+        throw new Error(`No files found in folder '${folderPath}'`);
+    }
+    // Read all files and create combined diff
+    const diffs = [];
+    const changedFiles = [];
+    for (const filePath of filePaths) {
+        try {
+            const content = fs.readFileSync(path.resolve(repoRoot, filePath), 'utf-8');
+            const lines = content.split('\n');
+            // Create artificial diff for this file
+            const fileDiff = lines.map((line, index) => `+${line}`).join('\n');
+            const diffHeader = `--- /dev/null\n+++ ${filePath}\n@@ -0,0 +1,${lines.length} @@\n`;
+            diffs.push(diffHeader + fileDiff);
+            changedFiles.push(filePath);
+        }
+        catch (error) {
+            // Skip files that can't be read (permissions, etc.)
+            console.warn(`Warning: Could not read file '${filePath}': ${error.message}`);
+        }
+    }
+    return {
+        diff: diffs.join('\n'),
+        changedFiles
+    };
+}
+/**
+ * Read content of multiple specified files and create artificial diff
+ */
+async function getMultipleFilesContent(repoRoot, filePaths) {
+    if (filePaths.length === 0) {
+        throw new Error('No files specified');
+    }
+    const diffs = [];
+    const changedFiles = [];
+    for (const filePath of filePaths) {
+        const fullPath = path.resolve(repoRoot, filePath);
+        // Check if file exists
+        if (!fs.existsSync(fullPath)) {
+            throw new Error(`File '${filePath}' not found`);
+        }
+        // Check if it's actually a file
+        const stats = fs.statSync(fullPath);
+        if (!stats.isFile()) {
+            throw new Error(`Path '${filePath}' is not a file`);
+        }
+        // Read file content
+        const content = fs.readFileSync(fullPath, 'utf-8');
+        const lines = content.split('\n');
+        // Create artificial diff for this file
+        const fileDiff = lines.map((line, index) => `+${line}`).join('\n');
+        const diffHeader = `--- /dev/null\n+++ ${filePath}\n@@ -0,0 +1,${lines.length} @@\n`;
+        diffs.push(diffHeader + fileDiff);
+        changedFiles.push(filePath);
+    }
+    return {
+        diff: diffs.join('\n'),
+        changedFiles
+    };
+}

package/dist/git/repo.js

@@ -0,0 +1,58 @@
+"use strict";
+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;
+const simple_git_1 = __importDefault(require("simple-git"));
+/**
+ * Gets repository name from git remote URL.
+ * Parses common formats: github.com/user/repo, gitlab.com/user/repo, etc.
+ * Returns null if no remote or parsing fails.
+ */
+async function getRepoName(repoRoot) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    try {
+        const remotes = await git.getRemotes(true);
+        const origin = remotes.find(r => r.name === 'origin');
+        if (!origin?.refs?.fetch) {
+            return null;
+        }
+        const url = origin.refs.fetch;
+        // Parse repo name from common URL formats:
+        // - https://github.com/user/repo.git
+        // - git@github.com:user/repo.git
+        // - https://gitlab.com/user/repo.git
+        // - git@gitlab.com:user/repo.git
+        const patterns = [
+            /(?:github\.com|gitlab\.com)[\/:]([^\/]+\/[^\/]+?)(?:\.git)?$/,
+            /([^\/]+\/[^\/]+?)(?:\.git)?$/
+        ];
+        for (const pattern of patterns) {
+            const match = url.match(pattern);
+            if (match && match[1]) {
+                return match[1];
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        // If no remote or error, return null
+        return null;
+    }
+}
+/**
+ * Gets current branch name from git.
+ * Returns null if not in a git repo or error occurs.
+ */
+async function getBranchName(repoRoot) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    try {
+        const branch = await git.revparse(['--abbrev-ref', 'HEAD']);
+        return branch || null;
+    }
+    catch (error) {
+        return null;
+    }
+}

package/dist/index.js

@@ -61,6 +61,12 @@ program
 program
     .command('check')
     .description('Check code against your threadlines')
-    .option('--api-url <url>', 'Threadline server URL', process.env.THREADLINE_API_URL || 'http://localhost:3000')
+    .option('--api-url <url>', 'Threadline server URL', process.env.THREADLINE_API_URL || (process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}` : 'http://localhost:3000'))
+    .option('--full', 'Show all results (compliant, attention, not_relevant). Default: only attention items')
+    .option('--branch <name>', 'Review all commits in branch vs base')
+    .option('--commit <sha>', 'Review specific commit')
+    .option('--file <path>', 'Review entire file (all lines as additions)')
+    .option('--folder <path>', 'Review all files in folder recursively')
+    .option('--files <paths...>', 'Review multiple specified files')
     .action(check_1.checkCommand);
 program.parse();

package/dist/utils/ci-detection.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAutoReviewTarget = getAutoReviewTarget;
+function getAutoReviewTarget() {
+    // 1. Check for PR/MR context (most authoritative)
+    // GitHub Actions PR
+    if (process.env.GITHUB_EVENT_NAME === 'pull_request') {
+        const targetBranch = process.env.GITHUB_BASE_REF;
+        const sourceBranch = process.env.GITHUB_HEAD_REF;
+        const prNumber = process.env.GITHUB_EVENT_PULL_REQUEST_NUMBER;
+        if (targetBranch && sourceBranch && prNumber) {
+            return {
+                type: 'pr',
+                value: prNumber,
+                sourceBranch,
+                targetBranch
+            };
+        }
+    }
+    // GitLab CI MR
+    if (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 mrNumber = process.env.CI_MERGE_REQUEST_IID;
+        if (targetBranch && sourceBranch && mrNumber) {
+            return {
+                type: 'mr',
+                value: mrNumber,
+                sourceBranch,
+                targetBranch
+            };
+        }
+    }
+    // 2. Check for branch name (CI with branch)
+    const branch = process.env.GITHUB_REF_NAME || // GitHub Actions
+        process.env.CI_COMMIT_REF_NAME || // GitLab CI
+        process.env.VERCEL_GIT_COMMIT_REF; // Vercel
+    if (branch) {
+        return {
+            type: 'branch',
+            value: branch
+        };
+    }
+    // 3. Check for commit SHA (CI without branch)
+    const commit = process.env.GITHUB_SHA || // GitHub Actions
+        process.env.CI_COMMIT_SHA || // GitLab CI
+        process.env.VERCEL_GIT_COMMIT_SHA; // Vercel
+    if (commit) {
+        return {
+            type: 'commit',
+            value: commit
+        };
+    }
+    // 4. Local development (no CI env vars)
+    return null;
+}

package/dist/utils/config.js

@@ -37,6 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getThreadlineApiKey = getThreadlineApiKey;
+exports.getThreadlineAccount = getThreadlineAccount;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const dotenv_1 = __importDefault(require("dotenv"));
@@ -61,3 +62,13 @@ function getThreadlineApiKey() {
     // Check environment variable (from shell or CI/CD)
     return process.env.THREADLINE_API_KEY;
 }
+/**
+ * Gets THREADLINE_ACCOUNT from environment.
+ * Priority: process.env.THREADLINE_ACCOUNT → .env.local file
+ */
+function getThreadlineAccount() {
+    // Load .env.local if it exists (doesn't override existing env vars)
+    loadEnvLocal();
+    // Check environment variable (from shell or CI/CD)
+    return process.env.THREADLINE_ACCOUNT;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadlines",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Threadline CLI - AI-powered linter based on your natural language documentation",
   "main": "dist/index.js",
   "bin": {
@@ -33,16 +33,18 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "commander": "^12.1.0",
-    "dotenv": "^16.4.7",
-    "simple-git": "^3.27.0",
     "axios": "^1.7.9",
     "chalk": "^4.1.2",
-    "js-yaml": "^4.1.0"
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.7",
+    "glob": "^13.0.0",
+    "js-yaml": "^4.1.0",
+    "simple-git": "^3.27.0"
   },
   "devDependencies": {
-    "@types/node": "^22.10.2",
+    "@types/glob": "^8.1.0",
     "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.10.2",
     "typescript": "^5.7.2"
   }
 }