threadlines 0.3.0 → 0.4.0

package/dist/api/client.js

@@ -1,27 +1,60 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReviewAPIClient = void 0;
-const axios_1 = __importDefault(require("axios"));
 class ReviewAPIClient {
     constructor(baseURL) {
-        this.client = axios_1.default.create({
-            baseURL,
-            timeout: 60000, // 60s timeout for entire request
-            headers: {
-                'Content-Type': 'application/json'
+        this.timeout = 60000; // 60s timeout for entire request
+        this.baseURL = baseURL;
+    }
+    async fetchWithTimeout(url, options) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(url, {
+                ...options,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            return response;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            // Handle AbortError from timeout
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(`Request timeout after ${this.timeout}ms`);
             }
-        });
+            throw error;
+        }
     }
     async review(request) {
-        const response = await this.client.post('/api/threadline-check', request);
-        return response.data;
+        const url = `${this.baseURL}/api/threadline-check`;
+        const response = await this.fetchWithTimeout(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP ${response.status}: ${errorText}`);
+        }
+        return await response.json();
     }
     async syncResults(request) {
-        const response = await this.client.post('/api/threadline-check-results', request);
-        return response.data;
+        const url = `${this.baseURL}/api/threadline-check-results`;
+        const response = await this.fetchWithTimeout(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP ${response.status}: ${errorText}`);
+        }
+        return await response.json();
     }
 }
 exports.ReviewAPIClient = ReviewAPIClient;

package/dist/commands/check.js

@@ -50,7 +50,7 @@ const expert_1 = require("../processors/expert");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
-const simple_git_1 = __importDefault(require("simple-git"));
+const child_process_1 = require("child_process");
 /**
  * Helper to get context for any environment.
  * CI environments use the unified getCIContext().
@@ -79,21 +79,22 @@ async function checkCommand(options) {
     const repoRoot = cwd; // Keep for backward compatibility with rest of function
     // Load configuration
     const config = await (0, config_file_1.loadConfig)(cwd);
-    logger_1.logger.info(`🔍 Threadline CLI v${CLI_VERSION}: Checking code against your threadlines...\n`);
+    logger_1.logger.info(`🔍 Threadline CLI v${CLI_VERSION}: Checking code against your threadlines...`);
     // Get git root for consistent file paths across monorepo
-    const git = (0, simple_git_1.default)(cwd);
     let gitRoot;
     try {
-        const isRepo = await git.checkIsRepo();
-        if (!isRepo) {
-            logger_1.logger.error('Not a git repository. Threadline requires a git repository.');
-            process.exit(1);
-        }
-        gitRoot = (await git.revparse(['--show-toplevel'])).trim();
+        // Check if we're in a git repo
+        (0, child_process_1.execSync)('git rev-parse --git-dir', { cwd: cwd, stdio: 'ignore' });
+        // Get git root
+        gitRoot = (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            encoding: 'utf-8',
+            cwd: cwd
+        }).trim();
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         logger_1.logger.error(`Failed to get git root: ${message}`);
+        logger_1.logger.error('Not a git repository. Threadline requires a git repository.');
         process.exit(1);
     }
     // Pre-flight check: Validate OpenAI API key is set (required for local processing)
@@ -232,11 +233,6 @@ async function checkCommand(options) {
         logger_1.logger.output('');
         process.exit(0);
     }
-    logger_1.logger.info(`✓ Found ${gitDiff.changedFiles.length} changed file(s) (context: ${reviewContext})\n`);
-    // Log the files being sent
-    for (const file of gitDiff.changedFiles) {
-        logger_1.logger.info(`  → ${file}`);
-    }
     // 4. Read context files for each threadline
     const threadlinesWithContext = threadlines.map(threadline => {
         const contextContent = {};

package/dist/git/ci-context.js

@@ -9,12 +9,9 @@
  *
  * This replaces the individual github.ts, gitlab.ts, bitbucket.ts, vercel.ts files.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCIContext = getCIContext;
-const simple_git_1 = __importDefault(require("simple-git"));
+const child_process_1 = require("child_process");
 const logger_1 = require("../utils/logger");
 const ci_config_1 = require("./ci-config");
 const diff_1 = require("./diff");
@@ -29,18 +26,19 @@ const diff_1 = require("./diff");
  * @param environment - The CI environment (github, gitlab, bitbucket, vercel)
  */
 async function getCIContext(repoRoot, environment) {
-    const git = (0, simple_git_1.default)(repoRoot);
     const config = ci_config_1.CI_CONFIGS[environment];
     // Check if we're in a git repo
-    const isRepo = await git.checkIsRepo();
-    if (!isRepo) {
+    try {
+        (0, child_process_1.execSync)('git rev-parse --git-dir', { cwd: repoRoot, stdio: 'ignore' });
+    }
+    catch {
         throw new Error('Not a git repository. Threadline requires a git repository.');
     }
     // === SHARED GIT COMMANDS (reliable across all CI environments) ===
     const repoName = await (0, diff_1.getRepoUrl)(repoRoot);
     const commitSha = await (0, diff_1.getHeadCommitSha)(repoRoot);
     const commitAuthor = await (0, diff_1.getCommitAuthor)(repoRoot);
-    const commitMessage = await (0, diff_1.getCommitMessage)(repoRoot, commitSha) || undefined;
+    const commitMessage = await (0, diff_1.getCommitMessage)(repoRoot, commitSha);
     // === CI-SPECIFIC ENV VARS (only for things git can't provide) ===
     const branchName = config.getBranchName();
     const isPR = config.isPullRequest();

package/dist/git/diff.js

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRepoUrl = getRepoUrl;
 exports.getHeadCommitSha = getHeadCommitSha;
@@ -9,7 +6,6 @@ exports.getCommitMessage = getCommitMessage;
 exports.getCommitAuthor = getCommitAuthor;
 exports.getPRDiff = getPRDiff;
 exports.getCommitDiff = getCommitDiff;
-const simple_git_1 = __importDefault(require("simple-git"));
 const child_process_1 = require("child_process");
 const logger_1 = require("../utils/logger");
 // =============================================================================
@@ -88,18 +84,33 @@ async function getHeadCommitSha(repoRoot) {
 }
 /**
  * Get commit message for a specific commit SHA
- * Returns full commit message (subject + body) or null if commit not found
+ *
+ * Fails loudly if commit cannot be retrieved (commit not found, git error, etc.).
+ * This function is only called when a commit is expected to exist:
+ * - In CI environments (always has HEAD commit)
+ * - In local environment with --commit flag (user explicitly provided SHA)
+ *
+ * @param repoRoot - Path to the repository root
+ * @param sha - Commit SHA to get message for
+ * @returns Full commit message (subject + body)
+ * @throws Error if commit cannot be retrieved
  */
 async function getCommitMessage(repoRoot, sha) {
-    const git = (0, simple_git_1.default)(repoRoot);
     try {
         // Get full commit message (subject + body)
-        const message = await git.show([sha, '--format=%B', '--no-patch']);
-        return message.trim() || null;
+        const message = (0, child_process_1.execSync)(`git show --format=%B --no-patch ${sha}`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
+        if (!message) {
+            throw new Error(`Commit ${sha} exists but has no message`);
+        }
+        return message;
     }
-    catch {
-        // Commit not found or invalid
-        return null;
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to get commit message for ${sha}: ${errorMessage}\n` +
+            `This commit should exist (called from CI or with --commit flag).`);
     }
 }
 /**
@@ -180,16 +191,19 @@ async function getCommitAuthor(repoRoot, sha) {
  * @param logger - Optional logger for debug output
  */
 async function getPRDiff(repoRoot, targetBranch, logger) {
-    const git = (0, simple_git_1.default)(repoRoot);
     // Fetch target branch on-demand (works with shallow clones)
     logger?.debug(`Fetching target branch: origin/${targetBranch}`);
     try {
-        await git.fetch(['origin', `${targetBranch}:refs/remotes/origin/${targetBranch}`, '--depth=1']);
+        (0, child_process_1.execSync)(`git fetch origin ${targetBranch}:refs/remotes/origin/${targetBranch} --depth=1`, {
+            cwd: repoRoot,
+            stdio: 'pipe' // Suppress fetch output
+        });
     }
     catch (fetchError) {
+        const errorMessage = fetchError instanceof Error ? fetchError.message : String(fetchError);
         throw new Error(`Failed to fetch target branch origin/${targetBranch}. ` +
             `This is required for PR/MR diff comparison. ` +
-            `Error: ${fetchError instanceof Error ? fetchError.message : 'Unknown error'}`);
+            `Error: ${errorMessage}`);
     }
     // Try three dots (merge base) first - shows only developer's changes
     // Falls back to two dots (direct comparison) if shallow clone prevents merge base calculation
@@ -200,9 +214,16 @@ async function getPRDiff(repoRoot, targetBranch, logger) {
         // This isolates developer changes by comparing against merge base
         // Works when we have enough history (full clones or GitHub's merge commits)
         logger?.debug(`Attempting three-dots diff (merge base): origin/${targetBranch}...HEAD`);
-        diff = await git.diff([`origin/${targetBranch}...HEAD`, '-U200']);
-        const diffSummary = await git.diffSummary([`origin/${targetBranch}...HEAD`]);
-        changedFiles = diffSummary.files.map(f => f.file);
+        diff = (0, child_process_1.execSync)(`git diff origin/${targetBranch}...HEAD -U200`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        });
+        // Get changed files using git diff --name-only
+        const changedFilesOutput = (0, child_process_1.execSync)(`git diff --name-only origin/${targetBranch}...HEAD`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
+        changedFiles = changedFilesOutput ? changedFilesOutput.split('\n') : [];
     }
     catch (error) {
         // Step 2: Fallback to "Risky" Diff (Two Dots)
@@ -215,9 +236,15 @@ async function getPRDiff(repoRoot, targetBranch, logger) {
         logger?.debug(`Fallback error: ${errorMessage}`);
         // Use two dots (direct comparison) - shows all differences between tips
         logger?.debug(`Using two-dots diff (direct comparison): origin/${targetBranch}..HEAD`);
-        diff = await git.diff([`origin/${targetBranch}..HEAD`, '-U200']);
-        const diffSummary = await git.diffSummary([`origin/${targetBranch}..HEAD`]);
-        changedFiles = diffSummary.files.map(f => f.file);
+        diff = (0, child_process_1.execSync)(`git diff origin/${targetBranch}..HEAD -U200`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        });
+        const changedFilesOutput = (0, child_process_1.execSync)(`git diff --name-only origin/${targetBranch}..HEAD`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
+        changedFiles = changedFilesOutput ? changedFilesOutput.split('\n') : [];
     }
     return {
         diff: diff || '',
@@ -250,7 +277,6 @@ async function getPRDiff(repoRoot, targetBranch, logger) {
  * @param sha - Commit SHA to get diff for (defaults to HEAD)
  */
 async function getCommitDiff(repoRoot, sha = 'HEAD') {
-    const git = (0, simple_git_1.default)(repoRoot);
     // Fetch parent commit on-demand to ensure git show can generate a proper diff
     // This works regardless of CI checkout depth settings (depth=1 or depth=2)
     // If parent is already available, fetch is fast/no-op; if not, we fetch it
@@ -295,7 +321,10 @@ async function getCommitDiff(repoRoot, sha = 'HEAD') {
     // If we get here, parentSha is guaranteed to be a valid 40-character SHA
     try {
         // Fetch just this one commit (depth=1 is fine, we only need the parent)
-        await git.fetch(['origin', parentSha, '--depth=1']);
+        (0, child_process_1.execSync)(`git fetch origin ${parentSha} --depth=1`, {
+            cwd: repoRoot,
+            stdio: 'pipe' // Suppress fetch output
+        });
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -312,10 +341,16 @@ async function getCommitDiff(repoRoot, sha = 'HEAD') {
     let changedFiles;
     try {
         // Use git diff to compare parent against HEAD (plumbing command, ignores shallow boundaries)
-        diff = await git.diff([`${parentSha}..${sha}`, '-U200']);
+        diff = (0, child_process_1.execSync)(`git diff ${parentSha}..${sha} -U200`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        });
         // Get changed files using git diff --name-only
-        const diffSummary = await git.diffSummary([`${parentSha}..${sha}`]);
-        changedFiles = diffSummary.files.map(f => f.file);
+        const changedFilesOutput = (0, child_process_1.execSync)(`git diff --name-only ${parentSha}..${sha}`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
+        changedFiles = changedFilesOutput ? changedFilesOutput.split('\n') : [];
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';

package/dist/git/local.js

@@ -11,21 +11,55 @@
  * - branchName: string
  * - commitAuthor: { name: string; email: string }
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+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.getLocalContext = getLocalContext;
-const simple_git_1 = __importDefault(require("simple-git"));
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const diff_1 = require("./diff");
+const logger_1 = require("../utils/logger");
 /**
  * Gets all Local context
  */
 async function getLocalContext(repoRoot, commitSha) {
-    const git = (0, simple_git_1.default)(repoRoot);
     // Check if we're in a git repo
-    const isRepo = await git.checkIsRepo();
-    if (!isRepo) {
+    try {
+        (0, child_process_1.execSync)('git rev-parse --git-dir', { cwd: repoRoot, stdio: 'ignore' });
+    }
+    catch {
         throw new Error('Not a git repository. Threadline requires a git repository.');
     }
     // Get all Local context
@@ -37,13 +71,10 @@ async function getLocalContext(repoRoot, commitSha) {
     const commitAuthor = commitSha
         ? await getCommitAuthorFromGit(repoRoot, commitSha)
         : await getCommitAuthorFromConfig(repoRoot);
-    // Get commit message if we have a SHA
+    // Get commit message if we have a SHA (fails loudly if commit doesn't exist)
     let commitMessage;
     if (commitSha) {
-        const message = await (0, diff_1.getCommitMessage)(repoRoot, commitSha);
-        if (message) {
-            commitMessage = message;
-        }
+        commitMessage = await (0, diff_1.getCommitMessage)(repoRoot, commitSha);
     }
     return {
         diff,
@@ -64,45 +95,162 @@ async function getLocalContext(repoRoot, commitSha) {
  * or review unstaged changes if nothing is staged.
  */
 async function getDiff(repoRoot) {
-    const git = (0, simple_git_1.default)(repoRoot);
-    // Get git status to determine what changes exist
-    const status = await git.status();
+    // Get git status in porcelain format to determine what changes exist
+    // Porcelain format: XY filename
+    // X = staged status, Y = unstaged status
+    // ' ' = no change, 'M' = modified, 'A' = added, 'D' = deleted, etc.
+    // '?' = untracked (only in Y position, X is always '?' too)
+    const statusOutput = (0, child_process_1.execSync)('git status --porcelain', {
+        encoding: 'utf-8',
+        cwd: repoRoot
+    }).trim();
+    const lines = statusOutput ? statusOutput.split('\n') : [];
+    const staged = [];
+    const unstaged = [];
+    const untracked = [];
+    for (const line of lines) {
+        const stagedStatus = line[0];
+        const unstagedStatus = line[1];
+        // Collect untracked files separately (they need special handling)
+        if (stagedStatus === '?' && unstagedStatus === '?') {
+            // Format: "?? filename" - skip 3 characters
+            const file = line.slice(3);
+            untracked.push(file);
+            continue;
+        }
+        // For tracked files, the format can be:
+        // - "M filename" (staged, no leading space) - skip 2 characters
+        // - " M filename" (unstaged, leading space) - skip 3 characters
+        // - "MM filename" (both staged and unstaged) - skip 3 characters
+        let file;
+        if (stagedStatus !== ' ' && unstagedStatus === ' ') {
+            // Staged only: "M filename" - skip 2 characters (M + space)
+            file = line.slice(2);
+        }
+        else {
+            // Unstaged or both: " M filename" or "MM filename" - skip 3 characters
+            file = line.slice(3);
+        }
+        if (stagedStatus !== ' ') {
+            staged.push(file);
+        }
+        if (unstagedStatus !== ' ' && unstagedStatus !== '?') {
+            unstaged.push(file);
+        }
+    }
     let diff;
     let changedFiles;
-    // Priority 1: Use staged changes if available
-    if (status.staged.length > 0) {
-        diff = await git.diff(['--cached', '-U200']);
-        // status.staged is an array of strings (file paths)
-        changedFiles = status.staged;
+    // Check if there are actually staged files (use git diff as source of truth)
+    // git status parsing can be inconsistent, so we verify with git diff
+    const stagedFilesOutput = (0, child_process_1.execSync)('git diff --cached --name-only', {
+        encoding: 'utf-8',
+        cwd: repoRoot
+    }).trim();
+    const actualStagedFiles = stagedFilesOutput ? stagedFilesOutput.split('\n') : [];
+    // Workflow A: Developer has staged files - check ONLY staged files
+    // (Ignore unstaged and untracked - developer explicitly chose to check staged)
+    if (actualStagedFiles.length > 0) {
+        diff = (0, child_process_1.execSync)('git diff --cached -U200', {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        });
+        changedFiles = actualStagedFiles;
+        // If staged files exist but diff is empty, something is wrong
+        if (!diff || diff.trim() === '') {
+            throw new Error(`Staged files exist but diff is empty. ` +
+                `This may indicate binary files, whitespace-only changes, or a git issue. ` +
+                `Staged files: ${actualStagedFiles.join(', ')}`);
+        }
+        logger_1.logger.info(`Checking STAGED changes (${changedFiles.length} file(s))`);
+        return {
+            diff: diff || '',
+            changedFiles
+        };
     }
-    // Priority 2: Use unstaged changes if no staged changes
-    else if (status.files.length > 0) {
-        diff = await git.diff(['-U200']);
-        changedFiles = status.files
-            .filter(f => f.working_dir !== ' ' || f.index !== ' ')
-            .map(f => f.path);
+    // No staged files - log clearly and continue to unstaged/untracked
+    if (staged.length > 0) {
+        // git status showed staged files but git diff doesn't - they were likely unstaged
+        logger_1.logger.info(`No staged files detected (files may have been unstaged), checking unstaged/untracked files instead.`);
     }
-    // No changes at all
     else {
+        logger_1.logger.info(`No staged files, checking unstaged/untracked files.`);
+    }
+    // Workflow B: Developer hasn't staged files - check unstaged + untracked files
+    // (Untracked files are conceptually "unstaged" - files being worked on but not committed)
+    if (unstaged.length > 0 || untracked.length > 0) {
+        // Get unstaged diff if there are unstaged files
+        if (unstaged.length > 0) {
+            diff = (0, child_process_1.execSync)('git diff -U200', {
+                encoding: 'utf-8',
+                cwd: repoRoot
+            });
+            const changedFilesOutput = (0, child_process_1.execSync)('git diff --name-only', {
+                encoding: 'utf-8',
+                cwd: repoRoot
+            }).trim();
+            changedFiles = changedFilesOutput ? changedFilesOutput.split('\n') : [];
+        }
+        else {
+            diff = '';
+            changedFiles = [];
+        }
+        // Handle untracked files: read their content and create artificial diffs
+        // Fails loudly if any untracked file cannot be read (permissions, filesystem errors, etc.)
+        const untrackedDiffs = [];
+        const untrackedFileList = [];
+        for (const file of untracked) {
+            const fullPath = path.resolve(repoRoot, file);
+            // Skip if it's a directory (git status can show directories)
+            const stats = fs.statSync(fullPath);
+            if (!stats.isFile()) {
+                continue;
+            }
+            // Read file content - fails loudly on any error (permissions, encoding, etc.)
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            // Normalize path to forward slashes for cross-platform consistency
+            const normalizedPath = file.replace(/\\/g, '/');
+            // Create artificial diff (all lines as additions, similar to getFileContent)
+            const lines = content.split('\n');
+            const fileDiff = lines.map((line) => `+${line}`).join('\n');
+            // Add git diff header (matches format expected by server's filterDiffByFiles)
+            const diffHeader = `diff --git a/${normalizedPath} b/${normalizedPath}\n--- /dev/null\n+++ b/${normalizedPath}\n@@ -0,0 +1,${lines.length} @@\n`;
+            untrackedDiffs.push(diffHeader + fileDiff);
+            untrackedFileList.push(normalizedPath);
+        }
+        // Combine unstaged changes with untracked files
+        const combinedDiff = untrackedDiffs.length > 0
+            ? (diff ? diff + '\n' : '') + untrackedDiffs.join('\n')
+            : diff;
+        const allChangedFiles = [...changedFiles, ...untrackedFileList];
+        const unstagedCount = changedFiles.length;
+        const untrackedCount = untrackedFileList.length;
+        if (unstagedCount > 0 && untrackedCount > 0) {
+            logger_1.logger.info(`Checking UNSTAGED changes (${unstagedCount} file(s)) + ${untrackedCount} untracked file(s)`);
+        }
+        else if (unstagedCount > 0) {
+            logger_1.logger.info(`Checking UNSTAGED changes (${unstagedCount} file(s))`);
+        }
+        else {
+            logger_1.logger.info(`Checking UNTRACKED files (${untrackedCount} file(s))`);
+        }
         return {
-            diff: '',
-            changedFiles: []
+            diff: combinedDiff || '',
+            changedFiles: allChangedFiles
         };
     }
-    return {
-        diff: diff || '',
-        changedFiles
-    };
+    // No changes at all - fail loudly
+    throw new Error('No changes detected. Stage files with "git add" or modify files to run threadlines.');
 }
 /**
  * Gets branch name for local environment
  * (Uses git command directly - works in local because not in detached HEAD state)
  */
 async function getBranchName(repoRoot) {
-    const git = (0, simple_git_1.default)(repoRoot);
     try {
-        const branchSummary = await git.branchLocal();
-        const currentBranch = branchSummary.current;
+        const currentBranch = (0, child_process_1.execSync)('git branch --show-current', {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
         if (!currentBranch) {
             throw new Error('Could not determine current branch. Are you in a git repository?');
         }
@@ -120,17 +268,22 @@ async function getBranchName(repoRoot) {
  * No fallbacks - if git config is not set or fails, throws an error.
  */
 async function getCommitAuthorFromConfig(repoRoot) {
-    const git = (0, simple_git_1.default)(repoRoot);
     try {
-        const name = await git.getConfig('user.name');
-        const email = await git.getConfig('user.email');
-        if (!name.value || !email.value) {
+        const name = (0, child_process_1.execSync)('git config --get user.name', {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
+        const email = (0, child_process_1.execSync)('git config --get user.email', {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
+        if (!name || !email) {
             throw new Error('Git config user.name or user.email is not set. ' +
                 'Run: git config user.name "Your Name" && git config user.email "your.email@example.com"');
         }
         return {
-            name: name.value.trim(),
-            email: email.value.trim()
+            name: name,
+            email: email
         };
     }
     catch (error) {

package/dist/processors/single-expert.js

@@ -1,16 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processThreadline = processThreadline;
-const openai_1 = __importDefault(require("openai"));
 const prompt_builder_1 = require("../llm/prompt-builder");
 const diff_filter_1 = require("../utils/diff-filter");
 const slim_diff_1 = require("../utils/slim-diff");
 const logger_1 = require("../utils/logger");
 async function processThreadline(threadline, diff, files, apiKey, model, serviceTier, contextLinesForLLM) {
-    const openai = new openai_1.default({ apiKey });
     // Filter files that match threadline patterns
     const relevantFiles = files.filter(file => threadline.patterns.some(pattern => matchesPattern(file, pattern)));
     // If no files match, return not_relevant
@@ -55,7 +50,8 @@ async function processThreadline(threadline, diff, files, apiKey, model, service
     let llmCallStatus = 'success';
     let llmCallErrorMessage = null;
     try {
-        const requestParams = {
+        // Build request body for OpenAI API (direct HTTP call - zero dependencies)
+        const requestBody = {
             model,
             messages: [
                 {
@@ -73,9 +69,63 @@ async function processThreadline(threadline, diff, files, apiKey, model, service
         // Add service_tier if not 'standard'
         const normalizedServiceTier = serviceTier.toLowerCase();
         if (normalizedServiceTier !== 'standard' && (normalizedServiceTier === 'auto' || normalizedServiceTier === 'default' || normalizedServiceTier === 'flex')) {
-            requestParams.service_tier = normalizedServiceTier;
+            requestBody.service_tier = normalizedServiceTier;
         }
-        const response = await openai.chat.completions.create(requestParams);
+        // Direct HTTP call to OpenAI API (native fetch - zero dependencies)
+        // Use AbortController for timeout (higher-level timeout in expert.ts is 40s, use 45s here as safety margin)
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 45000);
+        let httpResponse;
+        try {
+            httpResponse = await fetch('https://api.openai.com/v1/chat/completions', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(requestBody),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+        }
+        catch (fetchError) {
+            clearTimeout(timeoutId);
+            // Handle AbortError from timeout
+            if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+                throw new Error('Request timeout');
+            }
+            throw fetchError;
+        }
+        if (!httpResponse.ok) {
+            const errorText = await httpResponse.text();
+            let errorMessage = `HTTP ${httpResponse.status}: ${errorText}`;
+            // Try to parse OpenAI error structure
+            try {
+                const errorData = JSON.parse(errorText);
+                if (errorData.error) {
+                    errorMessage = errorData.error.message || errorText;
+                    // Create error object matching SDK error structure for compatibility
+                    const errorObj = new Error(errorMessage);
+                    errorObj.status = httpResponse.status;
+                    errorObj.error = {
+                        type: errorData.error.type,
+                        code: errorData.error.code,
+                        param: errorData.error.param,
+                    };
+                    throw errorObj;
+                }
+            }
+            catch (parseError) {
+                // If it's already our structured error, re-throw it
+                const structuredError = parseError;
+                if (structuredError.status) {
+                    throw parseError;
+                }
+                // Otherwise create a basic error
+                throw new Error(errorMessage);
+            }
+        }
+        const response = await httpResponse.json();
         // Capture the actual model returned by OpenAI (may differ from requested)
         const actualModel = response.model;
         llmCallFinishedAt = new Date().toISOString();
@@ -83,12 +133,12 @@ async function processThreadline(threadline, diff, files, apiKey, model, service
         // Capture token usage if available
         if (response.usage) {
             llmCallTokens = {
-                prompt_tokens: response.usage.prompt_tokens,
-                completion_tokens: response.usage.completion_tokens,
-                total_tokens: response.usage.total_tokens
+                prompt_tokens: response.usage.prompt_tokens || 0,
+                completion_tokens: response.usage.completion_tokens || 0,
+                total_tokens: response.usage.total_tokens || 0
             };
         }
-        const content = response.choices[0]?.message?.content;
+        const content = response.choices?.[0]?.message?.content;
         if (!content) {
             throw new Error('No response from LLM');
         }
@@ -145,13 +195,19 @@ async function processThreadline(threadline, diff, files, apiKey, model, service
         // Log full error for debugging
         logger_1.logger.error(`   ❌ OpenAI error: ${JSON.stringify(error, null, 2)}`);
         // Extract OpenAI error details from the error object
+        // Handle both SDK-style errors and HTTP errors
         const errorObj = error;
         const openAIError = errorObj?.error || {};
         const rawErrorResponse = {
             status: errorObj?.status,
             headers: errorObj?.headers,
             request_id: errorObj?.request_id,
-            error: errorObj?.error,
+            error: errorObj?.error || {
+                type: errorObj?.type,
+                code: errorObj?.code,
+                param: errorObj?.param,
+                message: errorObj?.message,
+            },
             code: errorObj?.code,
             param: errorObj?.param,
             type: errorObj?.type

package/dist/utils/config-file.js

@@ -32,15 +32,12 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_CONFIG = void 0;
 exports.loadConfig = loadConfig;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const simple_git_1 = __importDefault(require("simple-git"));
+const child_process_1 = require("child_process");
 exports.DEFAULT_CONFIG = {
     mode: 'online', // Default: sync enabled. Set to "offline" for local-only processing.
     api_url: 'https://devthreadline.com',
@@ -50,20 +47,24 @@ exports.DEFAULT_CONFIG = {
 };
 /**
  * Finds the git root directory by walking up from startDir.
- * Returns startDir if not in a git repository.
+ * Fails loudly if not in a git repository (this tool requires a git repo).
  */
 async function findGitRoot(startDir) {
     try {
-        const git = (0, simple_git_1.default)(startDir);
-        const isRepo = await git.checkIsRepo();
-        if (isRepo) {
-            return (await git.revparse(['--show-toplevel'])).trim();
-        }
+        // Check if we're in a git repo
+        (0, child_process_1.execSync)('git rev-parse --git-dir', { cwd: startDir, stdio: 'ignore' });
+        // Get git root
+        return (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            encoding: 'utf-8',
+            cwd: startDir
+        }).trim();
     }
-    catch {
-        // Not a git repo or error - return startDir
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Not a git repository. Threadline requires a git repository.\n` +
+            `Current directory: ${startDir}\n` +
+            `Error: ${errorMessage}`);
     }
-    return startDir;
 }
 /**
  * Loads configuration from .threadlinerc file.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadlines",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Threadlines CLI - AI-powered linter based on your natural language documentation",
   "main": "dist/index.js",
   "bin": {
@@ -48,14 +48,11 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "axios": "^1.7.9",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
     "dotenv": "^16.4.7",
     "glob": "^13.0.0",
-    "js-yaml": "^4.1.0",
-    "openai": "^4.73.1",
-    "simple-git": "^3.27.0"
+    "js-yaml": "^4.1.0"
   },
   "devDependencies": {
     "@types/glob": "^8.1.0",