threadlines 0.2.25 → 0.3.0

package/dist/utils/diff-filter.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Git Diff Filtering Utilities
+ *
+ * Filters git diffs to include only specific files.
+ * This is used to send only relevant files to each threadline's LLM call.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterDiffByFiles = filterDiffByFiles;
+exports.extractFilesFromDiff = extractFilesFromDiff;
+exports.filterHunkToChanges = filterHunkToChanges;
+exports.hasChanges = hasChanges;
+/**
+ * Filters a git diff to include only the specified files.
+ *
+ * Git diff format structure:
+ * - Each file section starts with "diff --git a/path b/path"
+ * - Followed by metadata lines (index, ---, +++)
+ * - Then hunks with "@@ -start,count +start,count @@" headers
+ * - Content lines (+, -, space-prefixed)
+ *
+ * @param diff - The full git diff string
+ * @param filesToInclude - Array of file paths to include (must match paths in diff)
+ * @returns Filtered diff containing only the specified files
+ */
+function filterDiffByFiles(diff, filesToInclude) {
+    if (!diff || diff.trim() === '') {
+        return '';
+    }
+    if (filesToInclude.length === 0) {
+        return '';
+    }
+    // Normalize file paths for comparison (handle both a/path and b/path formats)
+    const normalizedFiles = new Set(filesToInclude.map(file => file.trim()));
+    const lines = diff.split('\n');
+    const filteredLines = [];
+    let currentFile = null;
+    let inFileSection = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Check for file header: "diff --git a/path b/path"
+        const diffHeaderMatch = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
+        if (diffHeaderMatch) {
+            // Save previous file section if it was included
+            if (inFileSection && currentFile && normalizedFiles.has(currentFile)) {
+                // File section was included - it's already been added to filteredLines
+                // Reset for next file
+            }
+            // Start new file section
+            const filePathB = diffHeaderMatch[2];
+            // Use the 'b' path (new file) as the canonical path
+            currentFile = filePathB;
+            inFileSection = normalizedFiles.has(filePathB);
+            if (inFileSection) {
+                filteredLines.push(line);
+            }
+            continue;
+        }
+        // If we're in a file section that should be included, add all lines
+        if (inFileSection && currentFile && normalizedFiles.has(currentFile)) {
+            filteredLines.push(line);
+        }
+    }
+    return filteredLines.join('\n');
+}
+/**
+ * Extracts file paths from a git diff.
+ *
+ * @param diff - The git diff string
+ * @returns Array of file paths found in the diff
+ */
+function extractFilesFromDiff(diff) {
+    const files = new Set();
+    const lines = diff.split('\n');
+    for (const line of lines) {
+        const diffHeaderMatch = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
+        if (diffHeaderMatch) {
+            files.add(diffHeaderMatch[2]); // Use 'b' path
+        }
+    }
+    return Array.from(files);
+}
+/**
+ * Filters hunk content to show only changed lines (removes context lines).
+ * Context lines are lines that start with a space (unchanged code).
+ *
+ * @param hunkContent - The content of a hunk (array of lines)
+ * @returns Filtered hunk content with only changed lines (+ and -)
+ */
+function filterHunkToChanges(hunkContent) {
+    return hunkContent.filter(line => {
+        // Keep lines that start with + or - (actual changes)
+        // Remove lines that start with space (context/unchanged code)
+        return line.startsWith('+') || line.startsWith('-');
+    });
+}
+/**
+ * Checks if a hunk has any actual changes (not just context).
+ *
+ * @param hunkContent - The content of a hunk (array of lines)
+ * @returns True if the hunk contains actual changes
+ */
+function hasChanges(hunkContent) {
+    return hunkContent.some(line => line.startsWith('+') || line.startsWith('-'));
+}

package/dist/utils/logger.js

@@ -26,7 +26,9 @@ function isDebugEnabled() {
 /**
  * Logger utility for CLI output
  *
- * - debug/info: Only shown when --debug flag is set
+ * - debug: Only shown when --debug flag is set (technical details)
+ * - info: Always shown (important status messages)
+ * - output: Always shown (formatted output, no prefix)
  * - warn/error: Always shown (critical information)
  */
 exports.logger = {
@@ -40,13 +42,18 @@ exports.logger = {
         }
     },
     /**
-     * Info-level log (what's happening, progress updates)
-     * Only shown with --debug flag
+     * Info-level log (important status messages, progress updates)
+     * Always shown (important information users need to see)
      */
     info: (message) => {
-        if (debugEnabled) {
-            console.log(chalk_1.default.blue(`[INFO] ${message}`));
-        }
+        console.log(chalk_1.default.blue(`[INFO] ${message}`));
+    },
+    /**
+     * Output formatted text (for structured output like results display)
+     * Always shown, no prefix (for custom formatting)
+     */
+    output: (message) => {
+        console.log(message);
     },
     /**
      * Warning (non-fatal issues, recommendations)

package/dist/utils/slim-diff.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSlimDiff = createSlimDiff;
+/**
+ * Creates a slim version of a git diff with reduced context lines.
+ *
+ * Git diffs typically have 3 lines of context by default, but we may have
+ * diffs with much more context (e.g., 200 lines). This function creates
+ * a version with only the specified number of context lines around changes.
+ *
+ * @param fullDiff - The full git diff string
+ * @param contextLines - Number of context lines to keep above/below changes (default: 3)
+ * @returns A slim diff string with reduced context
+ */
+function createSlimDiff(fullDiff, contextLines = 3) {
+    if (!fullDiff || fullDiff.trim() === '') {
+        return '';
+    }
+    const lines = fullDiff.split('\n');
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        // File header: diff --git a/path b/path
+        if (line.startsWith('diff --git ')) {
+            result.push(line);
+            i++;
+            // Copy file metadata lines until we hit the first hunk
+            while (i < lines.length && !lines[i].startsWith('@@')) {
+                result.push(lines[i]);
+                i++;
+            }
+            continue;
+        }
+        // Hunk header: @@ -start,count +start,count @@
+        if (line.startsWith('@@')) {
+            // Process this hunk
+            i++;
+            // Collect all lines in this hunk (until next @@ or diff --git or end)
+            const hunkLines = [];
+            while (i < lines.length && !lines[i].startsWith('@@') && !lines[i].startsWith('diff --git ')) {
+                hunkLines.push(lines[i]);
+                i++;
+            }
+            // Find which lines are changes
+            const changeIndices = [];
+            for (let j = 0; j < hunkLines.length; j++) {
+                const hunkLine = hunkLines[j];
+                if (hunkLine.startsWith('+') || hunkLine.startsWith('-')) {
+                    changeIndices.push(j);
+                }
+            }
+            // If no changes in this hunk, skip it
+            if (changeIndices.length === 0) {
+                continue;
+            }
+            // Determine which lines to keep (changes + context)
+            const keepLines = new Set();
+            for (const changeIdx of changeIndices) {
+                // Keep the change line
+                keepLines.add(changeIdx);
+                // Keep N lines before
+                for (let k = 1; k <= contextLines; k++) {
+                    if (changeIdx - k >= 0) {
+                        keepLines.add(changeIdx - k);
+                    }
+                }
+                // Keep N lines after
+                for (let k = 1; k <= contextLines; k++) {
+                    if (changeIdx + k < hunkLines.length) {
+                        keepLines.add(changeIdx + k);
+                    }
+                }
+            }
+            // Build the slim hunk
+            const sortedKeepIndices = Array.from(keepLines).sort((a, b) => a - b);
+            const slimHunkLines = [];
+            for (const idx of sortedKeepIndices) {
+                slimHunkLines.push(hunkLines[idx]);
+            }
+            // Calculate new hunk header
+            // Count old and new lines
+            let oldLineCount = 0;
+            let newLineCount = 0;
+            for (const slimLine of slimHunkLines) {
+                if (slimLine.startsWith('-')) {
+                    oldLineCount++;
+                }
+                else if (slimLine.startsWith('+')) {
+                    newLineCount++;
+                }
+                else {
+                    // Context line counts for both
+                    oldLineCount++;
+                    newLineCount++;
+                }
+            }
+            // Parse original hunk header to get starting line numbers
+            const hunkHeaderMatch = line.match(/@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@(.*)?/);
+            if (hunkHeaderMatch) {
+                const oldStart = parseInt(hunkHeaderMatch[1], 10);
+                const newStart = parseInt(hunkHeaderMatch[2], 10);
+                const hunkTitle = hunkHeaderMatch[3] || '';
+                // Adjust starting line based on which lines we kept
+                // The first kept line's offset from the original hunk start
+                const firstKeptIdx = sortedKeepIndices[0];
+                let oldOffset = 0;
+                let newOffset = 0;
+                for (let j = 0; j < firstKeptIdx; j++) {
+                    const skippedLine = hunkLines[j];
+                    if (skippedLine.startsWith('-')) {
+                        oldOffset++;
+                    }
+                    else if (skippedLine.startsWith('+')) {
+                        newOffset++;
+                    }
+                    else {
+                        oldOffset++;
+                        newOffset++;
+                    }
+                }
+                const newOldStart = oldStart + oldOffset;
+                const newNewStart = newStart + newOffset;
+                result.push(`@@ -${newOldStart},${oldLineCount} +${newNewStart},${newLineCount} @@${hunkTitle}`);
+                result.push(...slimHunkLines);
+            }
+            continue;
+        }
+        // Any other line (shouldn't happen in well-formed diffs)
+        i++;
+    }
+    return result.join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadlines",
-  "version": "0.2.25",
+  "version": "0.3.0",
   "description": "Threadlines CLI - AI-powered linter based on your natural language documentation",
   "main": "dist/index.js",
   "bin": {
@@ -54,6 +54,7 @@
     "dotenv": "^16.4.7",
     "glob": "^13.0.0",
     "js-yaml": "^4.1.0",
+    "openai": "^4.73.1",
     "simple-git": "^3.27.0"
   },
   "devDependencies": {