ai-credit 1.0.2 → 1.0.4

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/ai-credit.svg)](https://www.npmjs.com/package/ai-credit)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-A command-line tool to track and analyze AI coding assistants' contributions in your codebase. Supports **Claude Code**, **Codex CLI**, **Gemini CLI**, and **Opencode**.
+A command-line tool to track and analyze AI coding assistants' contributions in your codebase (macOS/Linux). Supports **Claude Code**, **Codex CLI**, **Gemini CLI**, and **Opencode**.
 
 ## Quick Start
 
@@ -18,7 +18,7 @@ ai-credit
 
 ## Features
 
-- 🔍 **Auto-detection**: Automatically finds AI tool session data on your system
+- 🔍 **Auto-detection**: Automatically finds AI tool session data on your system (macOS/Linux)
 - 📊 **Detailed Statistics**: Lines of code, files modified, contribution ratios
 - 🤖 **Multi-tool Support**: Claude Code, Codex CLI, Gemini CLI, Opencode
 - 📈 **Visual Reports**: Console, JSON, and Markdown output formats
@@ -72,6 +72,7 @@ Shows which AI tools have data available on your system:
   Claude Code     ~/.claude/projects/              ✓ Available
   Codex CLI       ~/.codex/sessions/               ✓ Available
   Gemini CLI      ~/.gemini/tmp/                   ✗ Not found
+  Opencode        ~/.local/share/opencode/         ✓ Available
 ```
 
 ### File-level Analysis
@@ -101,35 +102,57 @@ Lists all AI sessions for the repository.
 ## Output Example
 
 ```
-╭─────────────────────────────────────────────────╮
-│ AI Contribution Analysis                        │
-│ Repository: /path/to/your/repo                  │
-│ Scan time: 2024-01-15 14:30:00                  │
-╰─────────────────────────────────────────────────╯
-
-                    📊 Overview
-┏━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
-┃ Metric       ┃ Value   ┃ AI Contribution     ┃
-┡━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━┩
-│ Total Files  │ 150     │ 45 (30.0%)          │
-│ Total Lines  │ 12500   │ 3750 (30.0%)        │
-│ AI Sessions  │ 28      │ -                   │
-└──────────────┴─────────┴─────────────────────┘
-
-              🤖 Contribution by AI Tool
-┏━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━━┓
-┃ Tool         ┃ Sessions ┃ Files ┃ Lines Added ┃
-┡━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━━┩
-│ Claude Code  │ 15       │ 30    │ +2500       │
-│ Codex CLI    │ 10       │ 20    │ +1000       │
-│ Opencode     │ 3        │ 5     │ +250        │
-└──────────────┴──────────┴───────┴─────────────┘
+ai-credit (main) npx ai-credit
+Leave a 🌟 star if you like it: https://github.com/debugtheworldbot/ai-credit
+
+╭──────────────────────────────────────────────────╮
+│ AI Contribution Analysis                         │
+│ Repository: /Users/eric/Developer/ai-credit      │
+│ Scan time: 2/2/2026, 4:22:53 PM                  │
+╰──────────────────────────────────────────────────╯
+📊 Overview
+┌─────────────┬───────┬─────────────────┐
+│ Metric      │ Value │ AI Contribution │
+├─────────────┼───────┼─────────────────┤
+│ Total Files │ 18    │ 15 (83.3%)      │
+├─────────────┼───────┼─────────────────┤
+│ Total Lines │ 3496  │ 1660 (47.5%)    │
+├─────────────┼───────┼─────────────────┤
+│ AI Sessions │ 6     │ -               │
+└─────────────┴───────┴─────────────────┘
+
+🤖 Contribution by AI Tool
+┌───────────────────────────────┬──────────┬───────┬─────────────┬───────────────┬──────────────────┐
+│ Tool / Model                  │ Sessions │ Files │ Lines Added │ Lines Removed │ Share            │
+├───────────────────────────────┼──────────┼───────┼─────────────┼───────────────┼──────────────────┤
+│ Opencode                      │ 2        │ 12    │ +558        │ -128          │ 32.2%            │
+├───────────────────────────────┼──────────┼───────┼─────────────┼───────────────┼──────────────────┤
+│   └─ kimi-k2.5-free           │ 2        │ 12    │ +558        │ -128          │ 100.0% (of tool) │
+├───────────────────────────────┼──────────┼───────┼─────────────┼───────────────┼──────────────────┤
+│ Codex CLI                     │ 1        │ 11    │ +482        │ -303          │ 27.8%            │
+├───────────────────────────────┼──────────┼───────┼─────────────┼───────────────┼──────────────────┤
+│   └─ gpt-5.2-codex            │ 1        │ 11    │ +482        │ -303          │ 100.0% (of tool) │
+├───────────────────────────────┼──────────┼───────┼─────────────┼───────────────┼──────────────────┤
+│ Gemini CLI                    │ 2        │ 11    │ +357        │ -262          │ 20.6%            │
+├───────────────────────────────┼──────────┼───────┼─────────────┼───────────────┼──────────────────┤
+│   └─ gemini-2.5-pro           │ 1        │ 8     │ +330        │ -237          │ 92.4% (of tool)  │
+├───────────────────────────────┼──────────┼───────┼─────────────┼───────────────┼──────────────────┤
+│   └─ gemini-3-pro-preview     │ 1        │ 5     │ +27         │ -25           │ 7.6% (of tool)   │
+├───────────────────────────────┼──────────┼───────┼─────────────┼───────────────┼──────────────────┤
+│ Claude Code                   │ 1        │ 5     │ +338        │ -452          │ 19.5%            │
+├───────────────────────────────┼──────────┼───────┼─────────────┼───────────────┼──────────────────┤
+│   └─ claude-opus-4-5-20251101 │ 1        │ 5     │ +338        │ -452          │ 100.0% (of tool) │
+└───────────────────────────────┴──────────┴───────┴─────────────┴───────────────┴──────────────────┘
 
 📈 Contribution Distribution
 
-  Claude Code  ████████████████████████████░░░░░░░░░░░░░░░░░░░░░░ 66.7%
-  Codex CLI    ████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 26.7%
-  Opencode     ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  6.7%
+  🟧🟧🟧🟧🟧🟧🟦🟦🟦🟦🟦🟪🟪🟪🟪🟪🟪🟩🟩🟩⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜
+
+  🟠 Opencode        15.3%  (534 lines)
+  🔵 Codex CLI       13.2%  (461 lines)
+  🟣 Gemini CLI       9.8%  (342 lines)
+  🟢 Claude Code      9.2%  (323 lines)
+  ⚪ Unknown/Human   52.5%  (1836 lines)
 ```
 
 ## Supported AI Tools
@@ -217,13 +240,14 @@ Here's a detailed breakdown of the parsing method for each supported tool:
 ### 3. Gemini CLI
 
 -   **File Format**: JSON (`.json`), where one file represents a complete session.
--   **Scan Path**: `~/.gemini/tmp/<project_hash>/chats/*.json`
+-   **Scan Paths**: `~/.gemini/tmp/<hash>/chats/*.json`, `~/.gemini/history/*.json`, `~/.gemini/sessions/*.json`
 -   **Parsing Logic**:
-    1.  The tool first calculates the corresponding `<project_hash>` from the target project path to locate the specific `chats` directory.
+    1.  The scanner searches Gemini’s session JSON files under common locations (`tmp`, `history`, `sessions`).
     2.  It parses the entire JSON file, which typically contains a `"messages"` or `"turns"` array logging the conversation history.
     3.  It iterates through the `messages` array, looking for `"parts"` arrays within messages from the `"assistant"` role.
-    4.  Within the `parts` array, it searches for an object containing a `"functionCall"`. This object's structure is similar to that of Codex CLI.
+    4.  Within the `parts` array, it searches for an object containing a `"functionCall"` (or `toolCalls`). This object's structure is similar to Codex CLI.
     5.  It extracts the `"name"` (function name) and `"args"` (arguments dictionary) from the `functionCall` object.
+    6.  **Project matching**: if the session JSON has an explicit project path (`projectPath/cwd/...`), it must match the target repo. If not, the scanner only keeps tool calls whose `file_path` is inside the target repo.
 
 **Example (Simplified Gemini CLI JSON Fragment):**
 
@@ -266,20 +290,23 @@ The tool applies a strict verification rule when calculating AI contribution sta
 
 1. **Parse AI Session Logs**: The scanner reads session files from each AI tool and extracts file change events (writes, edits, patches).
 
-2. **Extract Changed Content**: For each file change, the tool captures:
+2. **Build Repository File Set**: The tool gathers repository files using text-file extensions, excluding common build/vendor folders and honoring the root `.gitignore`.
+
+3. **Extract Changed Content**: For each file change, the tool captures:
    - The file path
    - Lines added (new content)
    - Lines removed (old content)
 
-3. **Verify Against Current Codebase**: Before counting any line as an AI contribution, the tool:
+4. **Verify Against Current Codebase**: Before counting any line as an AI contribution, the tool:
    - Reads the current content of the target file from the repository
    - For each line that AI claims to have added, checks if an **identical line** exists in the current file
    - Only lines that match exactly (character-for-character) are counted
 
-4. **Calculate Statistics**: The verified lines are then aggregated into:
+5. **Calculate Statistics**: The verified lines are then aggregated into:
    - Per-file contribution counts
    - Per-tool contribution totals
    - Overall repository contribution ratios
+   - **Sessions, files, and models are counted only when at least one verified line exists**
 
 ### Example
 
@@ -312,6 +339,7 @@ This methodology ensures that:
 - Cannot detect AI-generated code that was copy-pasted manually
 - Accuracy depends on the completeness of AI tool session logs
 - Some AI tools may not record all file operations
+- Files ignored by the root `.gitignore` are excluded from Total Files/Lines
 
 ## Contributing
 

package/dist/analyzer.js

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { glob } from 'glob';
+import ignore from 'ignore';
 import { ClaudeScanner, CodexScanner, GeminiScanner, OpencodeScanner, } from './scanners/index.js';
 /**
  * Main analyzer that coordinates all scanners and computes statistics
@@ -59,9 +60,19 @@ export class ContributionAnalyzer {
         const repoFiles = this.getRepoFiles();
         const repoFileIndex = this.buildRepoFileIndex(repoFiles);
         const totalLines = this.sumRepoLines(repoFileIndex);
+        // Filter sessions to those with verified contributions
+        const verifiedSessions = sessions.filter(session => {
+            for (const change of session.changes) {
+                const fileInfo = repoFileIndex.get(change.filePath);
+                if (this.countVerifiedAddedLines(change, fileInfo) > 0) {
+                    return true;
+                }
+            }
+            return false;
+        });
         // Compute statistics
-        const byTool = this.computeToolStats(sessions, repoFileIndex);
-        const byFile = this.computeFileStats(sessions, repoFileIndex);
+        const byTool = this.computeToolStats(verifiedSessions, repoFileIndex);
+        const byFile = this.computeFileStats(verifiedSessions, repoFileIndex);
         // Count AI-touched files and lines (only count files that exist in repo)
         let aiTouchedFiles = 0;
         let aiContributedLines = 0;
@@ -80,7 +91,7 @@ export class ContributionAnalyzer {
             totalLines,
             aiTouchedFiles,
             aiContributedLines,
-            sessions,
+            sessions: verifiedSessions,
             byTool,
             byFile,
         };
@@ -106,13 +117,13 @@ export class ContributionAnalyzer {
             '**/yarn.lock',
         ];
         try {
-            const files = glob.sync('**/*', {
+            let files = glob.sync('**/*', {
                 cwd: this.projectPath,
                 nodir: true,
                 ignore: ignorePatterns,
             });
             // Filter to only include text files
-            return files.filter(file => {
+            files = files.filter(file => {
                 const ext = path.extname(file).toLowerCase();
                 const textExtensions = [
                     '.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs',
@@ -132,6 +143,23 @@ export class ContributionAnalyzer {
                 ];
                 return textExtensions.includes(ext) || !ext;
             });
+            // Normalize to forward slashes so keys match scanner output on all platforms
+            files = files.map(file => file.replace(/\\/g, '/'));
+            const gitignorePath = path.join(this.projectPath, '.gitignore');
+            if (fs.existsSync(gitignorePath)) {
+                try {
+                    const gitignoreContent = fs.readFileSync(gitignorePath, 'utf-8');
+                    const ignoreFactory = ignore.default
+                        ?? ignore;
+                    const ig = ignoreFactory();
+                    ig.add(gitignoreContent.split(/\r?\n/));
+                    files = files.filter(file => !ig.ignores(file));
+                }
+                catch {
+                    // Ignore gitignore parsing errors
+                }
+            }
+            return files;
         }
         catch {
             return [];
@@ -219,6 +247,18 @@ export class ContributionAnalyzer {
         // Track unique files per model across all sessions
         const filesByModel = new Map();
         for (const session of sessions) {
+            const sessionContribs = [];
+            for (const change of session.changes) {
+                const fileInfo = repoFileIndex.get(change.filePath);
+                const verifiedAdded = this.countVerifiedAddedLines(change, fileInfo);
+                if (verifiedAdded <= 0)
+                    continue;
+                const modelName = change.model || session.model || 'unknown';
+                sessionContribs.push({ change, verifiedAdded, modelName });
+            }
+            if (sessionContribs.length === 0) {
+                continue;
+            }
             let toolStats = stats.get(session.tool);
             if (!toolStats) {
                 toolStats = {
@@ -237,10 +277,9 @@ export class ContributionAnalyzer {
             }
             toolStats.sessionsCount++;
             const toolFiles = filesByTool.get(session.tool);
-            for (const change of session.changes) {
+            const modelsInSession = new Set();
+            for (const { change, verifiedAdded, modelName } of sessionContribs) {
                 toolFiles.add(change.filePath);
-                const fileInfo = repoFileIndex.get(change.filePath);
-                const verifiedAdded = this.countVerifiedAddedLines(change, fileInfo);
                 toolStats.linesAdded += verifiedAdded;
                 toolStats.linesRemoved += change.linesRemoved;
                 if (change.changeType === 'create') {
@@ -249,13 +288,13 @@ export class ContributionAnalyzer {
                 else {
                     toolStats.filesModified++;
                 }
+                modelsInSession.add(modelName);
                 // Aggregate by model
-                const modelName = change.model || session.model || 'unknown';
                 let modelStats = toolStats.byModel.get(modelName);
                 if (!modelStats) {
                     modelStats = {
                         model: modelName,
-                        sessionsCount: 0, // Will be counted below (approximated by session presence)
+                        sessionsCount: 0, // Will be counted below
                         filesCreated: 0,
                         filesModified: 0,
                         totalFiles: 0,
@@ -277,21 +316,8 @@ export class ContributionAnalyzer {
                     modelStats.filesModified++;
                 }
             }
-            // Count sessions per model (if any change in session is attributed to model)
-            // This is a bit tricky if a session has mixed models, but usually it's one per session
-            const sessionModel = session.model || 'unknown';
-            // Use a set to track which models appeared in this session to avoid double counting if mixed
-            const modelsInSession = new Set();
-            if (session.model)
-                modelsInSession.add(session.model);
-            for (const change of session.changes) {
-                if (change.model)
-                    modelsInSession.add(change.model);
-            }
-            if (modelsInSession.size === 0)
-                modelsInSession.add('unknown');
             for (const modelName of modelsInSession) {
-                let modelStats = toolStats.byModel.get(modelName);
+                const modelStats = toolStats.byModel.get(modelName);
                 if (modelStats) {
                     modelStats.sessionsCount++;
                 }

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
-import { fileURLToPath } from 'url';
 import chalk from 'chalk';
-import * as path from 'path';
+import { Command } from 'commander';
 import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
 import { ContributionAnalyzer } from './analyzer.js';
 import { ConsoleReporter, JsonReporter, MarkdownReporter } from './reporter.js';
 import { AITool } from './types.js';
@@ -161,7 +161,7 @@ function parseTools(toolStr) {
 }
 const program = new Command();
 program
-    .name('ai-contrib')
+    .name('ai-credit')
     .description('CLI tool to track and analyze AI coding assistants\' contributions in your codebase')
     .version('1.0.0');
 // Main scan command

package/dist/reporter.js

@@ -1,6 +1,6 @@
-import * as fs from 'fs';
 import chalk from 'chalk';
 import Table from 'cli-table3';
+import * as fs from 'fs';
 import { AITool } from './types.js';
 /**
  * Tool display names
@@ -41,6 +41,7 @@ export class ConsoleReporter {
         const title = 'AI Contribution Analysis';
         const repoLine = `Repository: ${stats.repoPath}`;
         const timeLine = `Scan time: ${stats.scanTime.toLocaleString()}`;
+        console.log();
         console.log(chalk.dim('Leave a 🌟 star if you like it: https://github.com/debugtheworldbot/ai-credit'));
         console.log();
         console.log(chalk.cyan('╭' + '─'.repeat(boxWidth) + '╮'));
@@ -75,6 +76,7 @@ export class ConsoleReporter {
     printToolBreakdown(stats) {
         if (stats.byTool.size === 0) {
             console.log(chalk.yellow('No AI contributions found.'));
+            console.log();
             return;
         }
         console.log(chalk.bold('🤖 Contribution by AI Tool'));

package/dist/scanners/base.d.ts

@@ -49,6 +49,10 @@ export declare abstract class BaseScanner {
      * Extract added lines from a unified diff
      */
     protected extractAddedLinesFromDiff(diff: string | undefined): string[];
+    /**
+     * Normalize separators to forward slashes (consistent with glob output)
+     */
+    protected toForwardSlash(p: string): string;
     /**
      * Normalize file path relative to project
      */

package/dist/scanners/base.js

@@ -20,7 +20,7 @@ export class BaseScanner {
      * Resolve the full storage path
      */
     resolveStoragePath() {
-        return this.storagePath.replace('~', this.homeDir);
+        return path.join(this.storagePath.replace('~', this.homeDir));
     }
     /**
      * Count lines in a string
@@ -107,14 +107,20 @@ export class BaseScanner {
         }
         return added;
     }
+    /**
+     * Normalize separators to forward slashes (consistent with glob output)
+     */
+    toForwardSlash(p) {
+        return p.replace(/\\/g, '/');
+    }
     /**
      * Normalize file path relative to project
      */
     normalizePath(filePath, projectPath) {
         if (path.isAbsolute(filePath)) {
-            return path.relative(projectPath, filePath);
+            return this.toForwardSlash(path.relative(projectPath, filePath));
         }
-        return filePath;
+        return this.toForwardSlash(filePath);
     }
     /**
      * Check if a file path belongs to the project

package/dist/scanners/claude.d.ts

@@ -14,13 +14,17 @@ export declare class ClaudeScanner extends BaseScanner {
     get storagePath(): string;
     /**
      * Encode project path to match Claude's directory naming convention
-     * Claude encodes paths by replacing / with -
+     * Claude encodes paths by replacing / (and \ on Windows) with -
      */
     private encodeProjectPath;
     /**
      * Decode Claude's directory name back to a path
      */
     private decodeProjectPath;
+    /**
+     * Normalize a path for comparison (lowercase drive letter, forward slashes)
+     */
+    private normForCompare;
     scan(projectPath: string): AISession[];
     parseSessionFile(filePath: string, projectPath: string): AISession | null;
     /**

package/dist/scanners/claude.js

@@ -21,10 +21,10 @@ export class ClaudeScanner extends BaseScanner {
     }
     /**
      * Encode project path to match Claude's directory naming convention
-     * Claude encodes paths by replacing / with -
+     * Claude encodes paths by replacing / (and \ on Windows) with -
      */
     encodeProjectPath(projectPath) {
-        return projectPath.replace(/\//g, '-').replace(/^-/, '');
+        return projectPath.replace(/[\\/]/g, '-').replace(/^-/, '');
     }
     /**
      * Decode Claude's directory name back to a path
@@ -32,6 +32,17 @@ export class ClaudeScanner extends BaseScanner {
     decodeProjectPath(encodedPath) {
         return '/' + encodedPath.replace(/-/g, '/');
     }
+    /**
+     * Normalize a path for comparison (lowercase drive letter, forward slashes)
+     */
+    normForCompare(p) {
+        let s = this.toForwardSlash(p);
+        // Normalize Windows drive letter to lowercase: C:/... -> c:/...
+        if (/^[A-Z]:\//.test(s)) {
+            s = s[0].toLowerCase() + s.slice(1);
+        }
+        return s;
+    }
     scan(projectPath) {
         const sessions = [];
         const basePath = this.resolveStoragePath();
@@ -57,6 +68,8 @@ export class ClaudeScanner extends BaseScanner {
                     continue;
                 // Check various matching criteria
                 const decodedPath = this.decodeProjectPath(dir);
+                const normProject = this.normForCompare(projectPath);
+                const normDecoded = this.normForCompare(decodedPath);
                 // Match by:
                 // 1. Directory name contains project basename
                 // 2. Decoded path ends with project path
@@ -64,8 +77,8 @@ export class ClaudeScanner extends BaseScanner {
                 // 4. Same basename
                 if (dir.includes(projectBasename) ||
                     dir.toLowerCase().includes(projectBasename.toLowerCase()) ||
-                    decodedPath.endsWith(projectPath) ||
-                    projectPath.endsWith(decodedPath.slice(1)) ||
+                    normDecoded.endsWith(normProject) ||
+                    normProject.endsWith(normDecoded.slice(1)) ||
                     path.basename(decodedPath) === projectBasename) {
                     possibleDirs.add(fullDir);
                 }

package/dist/scanners/codex.d.ts

@@ -24,6 +24,10 @@ export declare class CodexScanner extends BaseScanner {
      * The session cwd must be exactly the project path or a subdirectory of it.
      */
     private pathsMatch;
+    /**
+     * Normalize a path for comparison (trim trailing slash, normalize Windows case).
+     */
+    private normForCompare;
     /**
      * Parse Codex apply_patch custom_tool_call entries.
      *
@@ -39,6 +43,14 @@ export declare class CodexScanner extends BaseScanner {
      *   *** End Patch
      */
     private parseApplyPatch;
+    /**
+     * Resolve the patch text from a Codex custom_tool_call payload.
+     */
+    private resolvePatchInput;
+    /**
+     * Resolve a file path against session cwd, then normalize to project-relative.
+     */
+    private resolveFilePath;
     /**
      * Parse a function_call payload (e.g. shell_command with file write operations)
      */

package/dist/scanners/codex.js

@@ -84,7 +84,7 @@ export class CodexScanner extends BaseScanner {
             }
             // Handle custom_tool_call (apply_patch) — the primary way Codex writes files
             if (entry.type === 'response_item' && payload.type === 'custom_tool_call') {
-                const patchChanges = this.parseApplyPatch(payload, projectPath, entry.timestamp);
+                const patchChanges = this.parseApplyPatch(payload, projectPath, sessionProjectPath, entry.timestamp);
                 changes.push(...patchChanges);
                 continue;
             }
@@ -100,7 +100,7 @@ export class CodexScanner extends BaseScanner {
                 catch {
                     continue;
                 }
-                const change = this.parseFunctionCall(funcName, args, projectPath, entry.timestamp);
+                const change = this.parseFunctionCall(funcName, args, projectPath, sessionProjectPath, entry.timestamp);
                 if (change) {
                     changes.push(change);
                 }
@@ -110,7 +110,7 @@ export class CodexScanner extends BaseScanner {
             const toolCalls = entry.tool_calls || entry.function_calls || [];
             if (Array.isArray(toolCalls)) {
                 for (const toolCall of toolCalls) {
-                    const change = this.parseToolCall(toolCall, projectPath, entry.timestamp);
+                    const change = this.parseToolCall(toolCall, projectPath, sessionProjectPath, entry.timestamp);
                     if (change) {
                         changes.push(change);
                     }
@@ -118,7 +118,7 @@ export class CodexScanner extends BaseScanner {
             }
             // Legacy: direct function format
             if (entry.function && entry.function.name) {
-                const change = this.parseToolCall({ function: entry.function }, projectPath, entry.timestamp);
+                const change = this.parseToolCall({ function: entry.function }, projectPath, sessionProjectPath, entry.timestamp);
                 if (change) {
                     changes.push(change);
                 }
@@ -129,7 +129,9 @@ export class CodexScanner extends BaseScanner {
             const normalizedSessionPath = path.resolve(sessionProjectPath);
             const normalizedProjectPath = path.resolve(projectPath);
             if (!this.pathsMatch(normalizedSessionPath, normalizedProjectPath)) {
-                return null;
+                if (changes.length === 0) {
+                    return null;
+                }
             }
         }
         if (changes.length === 0)
@@ -151,13 +153,26 @@ export class CodexScanner extends BaseScanner {
      * The session cwd must be exactly the project path or a subdirectory of it.
      */
     pathsMatch(sessionPath, projectPath) {
-        if (sessionPath === projectPath)
+        const s = this.normForCompare(sessionPath);
+        const p = this.normForCompare(projectPath);
+        if (s === p)
             return true;
         // Session opened inside a subdirectory of the project
-        if (sessionPath.startsWith(projectPath + '/'))
+        if (s.startsWith(p + '/'))
             return true;
         return false;
     }
+    /**
+     * Normalize a path for comparison (trim trailing slash, normalize Windows case).
+     */
+    normForCompare(p) {
+        let s = this.toForwardSlash(p).replace(/\/+$/, '');
+        const isWindowsPath = /^[A-Za-z]:\//.test(s) || s.startsWith('//');
+        if (isWindowsPath) {
+            s = s.toLowerCase();
+        }
+        return s;
+    }
     /**
      * Parse Codex apply_patch custom_tool_call entries.
      *
@@ -172,11 +187,11 @@ export class CodexScanner extends BaseScanner {
      *   +new file content
      *   *** End Patch
      */
-    parseApplyPatch(payload, projectPath, timestamp) {
+    parseApplyPatch(payload, projectPath, sessionCwd, timestamp) {
         const name = (payload.name || '').toLowerCase();
         if (name !== 'apply_patch')
             return [];
-        const input = payload.input || '';
+        const input = this.resolvePatchInput(payload);
         if (!input)
             return [];
         const changes = [];
@@ -188,17 +203,19 @@ export class CodexScanner extends BaseScanner {
         let addedLines = [];
         const flushFile = () => {
             if (currentFile && (linesAdded > 0 || linesRemoved > 0)) {
-                const filePath = this.normalizePath(currentFile, projectPath);
-                changes.push({
-                    filePath,
-                    linesAdded,
-                    linesRemoved,
-                    changeType,
-                    timestamp: timestamp ? new Date(timestamp) : new Date(),
-                    tool: this.tool,
-                    content: addedLines.join('\n'),
-                    addedLines,
-                });
+                const resolvedPath = this.resolveFilePath(currentFile, projectPath, sessionCwd);
+                if (resolvedPath) {
+                    changes.push({
+                        filePath: resolvedPath,
+                        linesAdded,
+                        linesRemoved,
+                        changeType,
+                        timestamp: timestamp ? new Date(timestamp) : new Date(),
+                        tool: this.tool,
+                        content: addedLines.join('\n'),
+                        addedLines,
+                    });
+                }
             }
             currentFile = null;
             linesAdded = 0;
@@ -244,10 +261,46 @@ export class CodexScanner extends BaseScanner {
         flushFile();
         return changes;
     }
+    /**
+     * Resolve the patch text from a Codex custom_tool_call payload.
+     */
+    resolvePatchInput(payload) {
+        const rawInput = payload?.input;
+        if (!rawInput)
+            return null;
+        if (typeof rawInput === 'string')
+            return rawInput;
+        if (Array.isArray(rawInput)) {
+            const parts = rawInput.filter(part => typeof part === 'string');
+            return parts.length > 0 ? parts.join('\n') : null;
+        }
+        if (typeof rawInput === 'object') {
+            const patch = rawInput.patch ||
+                rawInput.diff ||
+                rawInput.text ||
+                rawInput.content ||
+                rawInput.input;
+            return typeof patch === 'string' && patch ? patch : null;
+        }
+        return null;
+    }
+    /**
+     * Resolve a file path against session cwd, then normalize to project-relative.
+     */
+    resolveFilePath(filePath, projectPath, sessionCwd) {
+        let resolvedPath = filePath;
+        if (!path.isAbsolute(resolvedPath) && sessionCwd) {
+            resolvedPath = path.resolve(sessionCwd, resolvedPath);
+        }
+        if (!this.isProjectFile(resolvedPath, projectPath)) {
+            return null;
+        }
+        return this.normalizePath(resolvedPath, projectPath);
+    }
     /**
      * Parse a function_call payload (e.g. shell_command with file write operations)
      */
-    parseFunctionCall(funcName, args, projectPath, timestamp) {
+    parseFunctionCall(funcName, args, projectPath, sessionCwd, timestamp) {
         const writeOps = ['write_file', 'create_file', 'write', 'save_file', 'create', 'writefile'];
         const editOps = ['edit_file', 'apply_diff', 'patch', 'replace_in_file', 'edit', 'update_file', 'modify_file'];
         let filePath = args.path || args.file_path || args.filename || args.file || args.target || '';
@@ -255,7 +308,9 @@ export class CodexScanner extends BaseScanner {
         let oldContent = args.old_content || args.original || args.old_text || '';
         if (!filePath)
             return null;
-        filePath = this.normalizePath(filePath, projectPath);
+        const resolvedPath = this.resolveFilePath(filePath, projectPath, sessionCwd);
+        if (!resolvedPath)
+            return null;
         let changeType = 'modify';
         let linesAdded = 0;
         let linesRemoved = 0;
@@ -288,7 +343,7 @@ export class CodexScanner extends BaseScanner {
         if (linesAdded === 0 && linesRemoved === 0)
             return null;
         return {
-            filePath,
+            filePath: resolvedPath,
             linesAdded,
             linesRemoved,
             changeType,
@@ -301,7 +356,7 @@ export class CodexScanner extends BaseScanner {
     /**
      * Parse a legacy tool_call object to extract file changes
      */
-    parseToolCall(toolCall, projectPath, timestamp) {
+    parseToolCall(toolCall, projectPath, sessionCwd, timestamp) {
         const func = toolCall.function;
         if (!func)
             return null;
@@ -318,7 +373,7 @@ export class CodexScanner extends BaseScanner {
         catch {
             return null;
         }
-        return this.parseFunctionCall(funcName, args, projectPath, timestamp);
+        return this.parseFunctionCall(funcName, args, projectPath, sessionCwd, timestamp);
     }
     /**
      * Parse a unified diff to count added/removed lines

package/dist/scanners/gemini.d.ts

@@ -15,6 +15,7 @@ export declare class GeminiScanner extends BaseScanner {
     get storagePath(): string;
     /**
      * Hash project path to match Gemini's directory naming
+     * Normalize to forward slashes so the hash is consistent across platforms
      */
     private hashProjectPath;
     scan(projectPath: string): AISession[];
@@ -23,6 +24,10 @@ export declare class GeminiScanner extends BaseScanner {
      * Check if two paths match or are related
      */
     private pathsMatch;
+    /**
+     * Find explicit project path from known fields in the session data
+     */
+    private findProjectPath;
     /**
      * Parse a functionCall object to extract file changes
      */

package/dist/scanners/gemini.js

@@ -23,9 +23,11 @@ export class GeminiScanner extends BaseScanner {
     }
     /**
      * Hash project path to match Gemini's directory naming
+     * Normalize to forward slashes so the hash is consistent across platforms
      */
     hashProjectPath(projectPath) {
-        return crypto.createHash('md5').update(projectPath).digest('hex').substring(0, 16);
+        const normalized = this.toForwardSlash(projectPath);
+        return crypto.createHash('md5').update(normalized).digest('hex').substring(0, 16);
     }
     scan(projectPath) {
         const sessions = [];
@@ -100,8 +102,8 @@ export class GeminiScanner extends BaseScanner {
             sessionTimestamp = new Date(data.startTime);
         }
         // Try to find project path from various fields
-        sessionProjectPath = data.projectPath || data.project_path || data.cwd || data.working_directory || null;
-        // Filter by project path if available
+        sessionProjectPath = this.findProjectPath(data);
+        // Require explicit project path match when available
         if (sessionProjectPath) {
             const normalizedSessionPath = path.resolve(sessionProjectPath);
             const normalizedProjectPath = path.resolve(projectPath);
@@ -178,6 +180,15 @@ export class GeminiScanner extends BaseScanner {
         }
         if (changes.length === 0)
             return null;
+        // If no explicit project path, only keep changes that belong to the target project
+        if (!sessionProjectPath) {
+            const filteredChanges = changes.filter(change => this.isProjectFile(change.filePath, projectPath));
+            if (filteredChanges.length === 0) {
+                return null;
+            }
+            changes.length = 0;
+            changes.push(...filteredChanges);
+        }
         return {
             id: this.generateSessionId(filePath),
             tool: this.tool,
@@ -194,17 +205,58 @@ export class GeminiScanner extends BaseScanner {
      * Check if two paths match or are related
      */
     pathsMatch(path1, path2) {
-        // Exact match
-        if (path1 === path2)
-            return true;
-        // One contains the other
-        if (path1.startsWith(path2) || path2.startsWith(path1))
+        const p1 = this.toForwardSlash(path1);
+        const p2 = this.toForwardSlash(path2);
+        if (p1 === p2)
             return true;
-        // Same basename (project name)
-        if (path.basename(path1) === path.basename(path2))
+        if (p1.startsWith(p2 + '/'))
             return true;
         return false;
     }
+    /**
+     * Find explicit project path from known fields in the session data
+     */
+    findProjectPath(data) {
+        if (!data || typeof data !== 'object')
+            return null;
+        const keys = new Set([
+            'projectPath',
+            'project_path',
+            'cwd',
+            'working_directory',
+            'workspace',
+            'workspacePath',
+            'rootPath',
+            'repoPath',
+        ]);
+        const queue = [{ value: data, depth: 0 }];
+        const maxDepth = 6;
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current)
+                break;
+            const { value, depth } = current;
+            if (!value || typeof value !== 'object')
+                continue;
+            if (depth > maxDepth)
+                continue;
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    queue.push({ value: item, depth: depth + 1 });
+                }
+                continue;
+            }
+            for (const [key, val] of Object.entries(value)) {
+                if (keys.has(key) && typeof val === 'string' && path.isAbsolute(val)) {
+                    return val;
+                }
+                if (val && typeof val === 'object') {
+                    queue.push({ value: val, depth: depth + 1 });
+                }
+            }
+        }
+        return null;
+    }
     /**
      * Parse a functionCall object to extract file changes
      */

package/dist/scanners/opencode.js

@@ -136,11 +136,13 @@ export class OpencodeScanner extends BaseScanner {
      * Check if two paths match (session belongs to project)
      */
     pathsMatch(sessionPath, projectPath) {
-        if (sessionPath === projectPath)
+        const s = this.toForwardSlash(sessionPath);
+        const p = this.toForwardSlash(projectPath);
+        if (s === p)
             return true;
-        if (sessionPath.startsWith(projectPath + path.sep))
+        if (s.startsWith(p + '/'))
             return true;
-        if (projectPath.startsWith(sessionPath + path.sep))
+        if (p.startsWith(s + '/'))
             return true;
         if (path.basename(sessionPath) === path.basename(projectPath))
             return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-credit",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "CLI tool to track and analyze AI coding assistants' contributions in your codebase",
   "main": "dist/index.js",
   "type": "module",
@@ -11,7 +11,7 @@
     "build": "tsc",
     "start": "node dist/cli.js",
     "dev": "tsc && node dist/cli.js",
-    "pub": "npm run build && npm publish",
+    "pub": "npm version patch && npm run build && npm publish --access public",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -37,7 +37,8 @@
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",
-    "glob": "^10.4.5"
+    "glob": "^10.4.5",
+    "ignore": "^5.3.1"
   },
   "devDependencies": {
     "@types/node": "^20.14.0",

package/dist/scanners/aider.d.ts

@@ -1,35 +0,0 @@
-import { AISession, AITool } from '../types.js';
-import { BaseScanner } from './base.js';
-/**
- * Scanner for Aider sessions
- *
- * Aider stores chat history in:
- * <project>/.aider.chat.history.md
- * <project>/.aider.input.history
- * <project>/.aider/
- *
- * The file contains markdown-formatted conversation with
- * code blocks that show file changes.
- */
-export declare class AiderScanner extends BaseScanner {
-    get tool(): AITool;
-    get storagePath(): string;
-    /**
-     * For Aider, storage is project-local
-     */
-    protected resolveStoragePath(): string;
-    scan(projectPath: string): AISession[];
-    /**
-     * Check if Aider history exists in the project
-     */
-    isAvailable(): boolean;
-    /**
-     * Check if Aider history exists for a specific project
-     */
-    isAvailableForProject(projectPath: string): boolean;
-    parseSessionFile(filePath: string, projectPath: string): AISession | null;
-    /**
-     * Deduplicate changes, keeping the latest for each file
-     */
-    private deduplicateChanges;
-}

package/dist/scanners/aider.js

@@ -1,205 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
-import { AITool } from '../types.js';
-import { BaseScanner } from './base.js';
-/**
- * Scanner for Aider sessions
- *
- * Aider stores chat history in:
- * <project>/.aider.chat.history.md
- * <project>/.aider.input.history
- * <project>/.aider/
- *
- * The file contains markdown-formatted conversation with
- * code blocks that show file changes.
- */
-export class AiderScanner extends BaseScanner {
-    get tool() {
-        return AITool.AIDER;
-    }
-    get storagePath() {
-        return '.aider.chat.history.md';
-    }
-    /**
-     * For Aider, storage is project-local
-     */
-    resolveStoragePath() {
-        return this.storagePath;
-    }
-    scan(projectPath) {
-        const sessions = [];
-        // Check for main history file
-        const historyFile = path.join(projectPath, '.aider.chat.history.md');
-        if (fs.existsSync(historyFile)) {
-            const session = this.parseSessionFile(historyFile, projectPath);
-            if (session && session.changes.length > 0) {
-                sessions.push(session);
-            }
-        }
-        // Also check .aider directory for additional history
-        const aiderDir = path.join(projectPath, '.aider');
-        if (fs.existsSync(aiderDir)) {
-            try {
-                const files = glob.sync('**/*.md', { cwd: aiderDir });
-                for (const file of files) {
-                    if (file.includes('history') || file.includes('chat')) {
-                        const session = this.parseSessionFile(path.join(aiderDir, file), projectPath);
-                        if (session && session.changes.length > 0) {
-                            sessions.push(session);
-                        }
-                    }
-                }
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-        return sessions;
-    }
-    /**
-     * Check if Aider history exists in the project
-     */
-    isAvailable() {
-        // For Aider, we can't check globally - it's project-specific
-        return true;
-    }
-    /**
-     * Check if Aider history exists for a specific project
-     */
-    isAvailableForProject(projectPath) {
-        const historyFile = path.join(projectPath, this.storagePath);
-        const aiderDir = path.join(projectPath, '.aider');
-        return fs.existsSync(historyFile) || fs.existsSync(aiderDir);
-    }
-    parseSessionFile(filePath, projectPath) {
-        let content;
-        try {
-            content = fs.readFileSync(filePath, 'utf-8');
-        }
-        catch {
-            return null;
-        }
-        const changes = [];
-        const fileStats = fs.statSync(filePath);
-        const sessionTimestamp = fileStats.mtime;
-        // Parse the markdown content to find file changes
-        // Aider uses various patterns:
-        // Pattern 1: ```language path/to/file.py
-        const codeBlockRegex = /```(\w+)?\s+([^\n`]+)\n([\s\S]*?)```/g;
-        let match;
-        while ((match = codeBlockRegex.exec(content)) !== null) {
-            const [, language, filePathRaw, code] = match;
-            // Skip if it looks like a diff or command output
-            if (filePathRaw.startsWith('>') || filePathRaw.startsWith('$') || filePathRaw.startsWith('#')) {
-                continue;
-            }
-            // Clean up the file path
-            const cleanPath = filePathRaw.trim();
-            // Skip if path contains spaces (likely not a real path) or is too long
-            if (!cleanPath || cleanPath.includes('  ') || cleanPath.length > 200) {
-                continue;
-            }
-            // Skip common non-file patterns
-            if (cleanPath.match(/^(bash|shell|console|output|diff|patch|error|warning|note|example)/i)) {
-                continue;
-            }
-            const linesAdded = this.countLines(code);
-            if (linesAdded > 0) {
-                changes.push({
-                    filePath: this.normalizePath(cleanPath, projectPath),
-                    linesAdded,
-                    linesRemoved: 0,
-                    changeType: 'modify',
-                    timestamp: sessionTimestamp,
-                    tool: this.tool,
-                    content: code,
-                    addedLines: this.extractNonEmptyLines(code),
-                });
-            }
-        }
-        // Pattern 2: SEARCH/REPLACE blocks (Aider's edit format)
-        // Look for file context before SEARCH/REPLACE
-        const fileEditRegex = /(?:^|\n)([^\n]+\.[a-zA-Z]+)\n```[^\n]*\n<<<<<<< SEARCH\n([\s\S]*?)\n=======\n([\s\S]*?)\n>>>>>>> REPLACE/g;
-        while ((match = fileEditRegex.exec(content)) !== null) {
-            const [, filePathRaw, searchContent, replaceContent] = match;
-            const cleanPath = filePathRaw.trim();
-            if (cleanPath && !cleanPath.includes(' ')) {
-                const linesRemoved = this.countLines(searchContent);
-                const linesAdded = this.countLines(replaceContent);
-                if (linesAdded > 0 || linesRemoved > 0) {
-                    changes.push({
-                        filePath: this.normalizePath(cleanPath, projectPath),
-                        linesAdded,
-                        linesRemoved,
-                        changeType: 'modify',
-                        timestamp: sessionTimestamp,
-                        tool: this.tool,
-                        content: replaceContent,
-                        addedLines: this.extractNonEmptyLines(replaceContent),
-                    });
-                }
-            }
-        }
-        // Pattern 3: Standalone SEARCH/REPLACE without file context
-        const standaloneEditRegex = /<<<<<<< SEARCH\n([\s\S]*?)\n=======\n([\s\S]*?)\n>>>>>>> REPLACE/g;
-        while ((match = standaloneEditRegex.exec(content)) !== null) {
-            const [fullMatch, searchContent, replaceContent] = match;
-            // Skip if already captured by fileEditRegex
-            if (content.indexOf(fullMatch) !== match.index)
-                continue;
-            const linesRemoved = this.countLines(searchContent);
-            const linesAdded = this.countLines(replaceContent);
-            if (linesAdded > 0 || linesRemoved > 0) {
-                changes.push({
-                    filePath: 'unknown',
-                    linesAdded,
-                    linesRemoved,
-                    changeType: 'modify',
-                    timestamp: sessionTimestamp,
-                    tool: this.tool,
-                    content: replaceContent,
-                    addedLines: this.extractNonEmptyLines(replaceContent),
-                });
-            }
-        }
-        // Deduplicate changes by file path
-        const uniqueChanges = this.deduplicateChanges(changes);
-        if (uniqueChanges.length === 0)
-            return null;
-        return {
-            id: this.generateSessionId(filePath),
-            tool: this.tool,
-            timestamp: sessionTimestamp,
-            projectPath,
-            changes: uniqueChanges,
-            totalFilesChanged: new Set(uniqueChanges.map(c => c.filePath)).size,
-            totalLinesAdded: uniqueChanges.reduce((sum, c) => sum + c.linesAdded, 0),
-            totalLinesRemoved: uniqueChanges.reduce((sum, c) => sum + c.linesRemoved, 0),
-        };
-    }
-    /**
-     * Deduplicate changes, keeping the latest for each file
-     */
-    deduplicateChanges(changes) {
-        const byFile = new Map();
-        for (const change of changes) {
-            const existing = byFile.get(change.filePath);
-            if (!existing) {
-                byFile.set(change.filePath, { ...change });
-            }
-            else {
-                // Accumulate lines
-                existing.linesAdded += change.linesAdded;
-                existing.linesRemoved += change.linesRemoved;
-                if (change.addedLines && change.addedLines.length > 0) {
-                    if (!existing.addedLines) {
-                        existing.addedLines = [];
-                    }
-                    existing.addedLines.push(...change.addedLines);
-                }
-            }
-        }
-        return Array.from(byFile.values()).filter(c => c.filePath !== 'unknown');
-    }
-}