ai-credit 1.0.3 → 1.0.5

package/README.md

@@ -3,7 +3,9 @@
 [![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/Windows). Supports **Claude Code**, **Codex CLI**, **Gemini CLI**, and **Opencode**.
+
+<img width="700" height="700" alt="image" src="https://github.com/user-attachments/assets/48545b91-8d20-4946-bc1c-f55762c01539" />
 
 ## Quick Start
 
@@ -18,7 +20,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/Windows)
 - 📊 **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 +74,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 +104,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 +242,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):**
 
@@ -250,6 +276,46 @@ Here's a detailed breakdown of the parsing method for each supported tool:
 }
 ```
 
+### 4. Opencode
+
+-   **File Format**: JSON (`.json`) session and message files.
+-   **Scan Paths**:
+    -   Sessions: `~/.local/share/opencode/storage/session/**/*.json`
+    -   Messages: `~/.local/share/opencode/storage/message/<session-id>/*.json`
+-   **Parsing Logic**:
+    1.  The scanner reads all session JSON files (stored under project-hash subfolders).
+    2.  It filters sessions by project path using `directory` or `projectPath` in the session metadata.
+    3.  If message files exist for the session, it parses each message and looks for `summary.diffs`.
+    4.  If no message-level diffs are found, it falls back to `summary.diffs` in the session file.
+    5.  Each diff entry provides:
+        -   `file`: relative file path
+        -   `before`: previous content
+        -   `after`: new content
+        -   `additions` / `deletions`: optional precomputed line counts
+    6.  Lines added/removed are taken from `additions`/`deletions` when present, otherwise computed from `before`/`after`.
+    7.  The scanner also extracts the model from message data (e.g., `model.modelID`) when available.
+
+**Example (Simplified Opencode Message JSON):**
+
+```json
+{
+  "sessionID": "sess_abc123",
+  "time": { "created": "2026-02-02T10:15:00Z" },
+  "model": { "modelID": "kimi-k2.5-free" },
+  "summary": {
+    "diffs": [
+      {
+        "file": "src/index.ts",
+        "before": "console.log('old');\n",
+        "after": "console.log('new');\n",
+        "additions": 1,
+        "deletions": 1
+      }
+    ]
+  }
+}
+```
+
 ### Summary
 
 In essence, `ai-credit` features a specialized scanner for each supported AI tool. Each scanner is programmed to know its corresponding tool's log storage location and data structure. During analysis, the main program invokes all available scanners, collects all `FileChange` events related to the target project, and then aggregates, deduplicates, and analyzes these events to generate the final contribution report.
@@ -266,20 +332,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 +381,8 @@ 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
+- Windows support for some tools depends on their session storage format compatibility
 
 ## 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

@@ -76,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

@@ -45,10 +45,21 @@ export declare abstract class BaseScanner {
      * Compute added lines using LCS diff (non-empty lines only)
      */
     protected diffAddedLines(before: string | undefined, after: string | undefined): string[];
+    /**
+     * Compute added/removed line counts using LCS diff (non-empty lines only)
+     */
+    protected diffLineCounts(before: string | undefined, after: string | undefined): {
+        added: number;
+        removed: number;
+    };
     /**
      * 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
@@ -89,6 +89,40 @@ export class BaseScanner {
         }
         return added.reverse();
     }
+    /**
+     * Compute added/removed line counts using LCS diff (non-empty lines only)
+     */
+    diffLineCounts(before, after) {
+        const beforeLines = this.extractNonEmptyLines(before);
+        const afterLines = this.extractNonEmptyLines(after);
+        if (beforeLines.length === 0)
+            return { added: afterLines.length, removed: 0 };
+        if (afterLines.length === 0)
+            return { added: 0, removed: beforeLines.length };
+        const m = beforeLines.length;
+        const n = afterLines.length;
+        let prev = new Array(n + 1).fill(0);
+        let curr = new Array(n + 1).fill(0);
+        for (let i = 1; i <= m; i++) {
+            for (let j = 1; j <= n; j++) {
+                if (beforeLines[i - 1] === afterLines[j - 1]) {
+                    curr[j] = prev[j - 1] + 1;
+                }
+                else {
+                    curr[j] = Math.max(prev[j], curr[j - 1]);
+                }
+            }
+            const temp = prev;
+            prev = curr;
+            curr = temp;
+            curr.fill(0);
+        }
+        const lcs = prev[n];
+        return {
+            added: afterLines.length - lcs,
+            removed: beforeLines.length - lcs,
+        };
+    }
     /**
      * Extract added lines from a unified diff
      */
@@ -107,14 +141,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);
                 }
@@ -174,18 +187,28 @@ export class ClaudeScanner extends BaseScanner {
         let addedLines = [];
         if (writeOps.includes(toolName)) {
             changeType = oldContent ? 'modify' : 'create';
-            linesAdded = this.countLines(newContent);
-            linesRemoved = this.countLines(oldContent);
-            addedLines = this.extractNonEmptyLines(newContent);
+            const stats = this.diffLineCounts(oldContent, newContent);
+            linesAdded = stats.added;
+            linesRemoved = stats.removed;
+            if (oldContent && newContent) {
+                addedLines = this.diffAddedLines(oldContent, newContent);
+            }
+            else {
+                addedLines = this.extractNonEmptyLines(newContent);
+            }
         }
         else if (editOps.includes(toolName)) {
             changeType = 'modify';
-            linesAdded = this.countLines(newContent);
-            linesRemoved = this.countLines(oldContent);
             if (oldContent && newContent) {
+                const stats = this.diffLineCounts(oldContent, newContent);
+                linesAdded = stats.added;
+                linesRemoved = stats.removed;
                 addedLines = this.diffAddedLines(oldContent, newContent);
             }
             else {
+                const stats = this.diffLineCounts(oldContent, newContent);
+                linesAdded = stats.added;
+                linesRemoved = stats.removed;
                 addedLines = this.extractNonEmptyLines(newContent);
             }
         }

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,20 +308,27 @@ 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;
         let addedLines = [];
         if (writeOps.includes(funcName)) {
-            changeType = 'create';
-            linesAdded = this.countLines(newContent);
-            addedLines = this.extractNonEmptyLines(newContent);
+            changeType = oldContent ? 'modify' : 'create';
+            const stats = this.diffLineCounts(oldContent, newContent);
+            linesAdded = stats.added;
+            linesRemoved = stats.removed;
+            if (oldContent && newContent) {
+                addedLines = this.diffAddedLines(oldContent, newContent);
+            }
+            else {
+                addedLines = this.extractNonEmptyLines(newContent);
+            }
         }
         else if (editOps.includes(funcName)) {
             changeType = 'modify';
-            linesAdded = this.countLines(newContent);
-            linesRemoved = this.countLines(oldContent);
             if ((funcName === 'apply_diff' || funcName === 'patch') && args.diff) {
                 const diffStats = this.parseDiff(args.diff);
                 linesAdded = diffStats.added;
@@ -276,9 +336,15 @@ export class CodexScanner extends BaseScanner {
                 addedLines = this.extractAddedLinesFromDiff(args.diff);
             }
             else if (oldContent && newContent) {
+                const stats = this.diffLineCounts(oldContent, newContent);
+                linesAdded = stats.added;
+                linesRemoved = stats.removed;
                 addedLines = this.diffAddedLines(oldContent, newContent);
             }
             else {
+                const stats = this.diffLineCounts(oldContent, newContent);
+                linesAdded = stats.added;
+                linesRemoved = stats.removed;
                 addedLines = this.extractNonEmptyLines(newContent);
             }
         }
@@ -288,7 +354,7 @@ export class CodexScanner extends BaseScanner {
         if (linesAdded === 0 && linesRemoved === 0)
             return null;
         return {
-            filePath,
+            filePath: resolvedPath,
             linesAdded,
             linesRemoved,
             changeType,
@@ -301,7 +367,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 +384,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)
+        const p1 = this.toForwardSlash(path1);
+        const p2 = this.toForwardSlash(path2);
+        if (p1 === p2)
             return true;
-        // One contains the other
-        if (path1.startsWith(path2) || path2.startsWith(path1))
-            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
      */
@@ -232,9 +284,15 @@ export class GeminiScanner extends BaseScanner {
         let linesRemoved = 0;
         let addedLines = [];
         if (writeOps.includes(funcName)) {
-            linesAdded = this.countLines(newContent);
-            linesRemoved = this.countLines(oldContent); // Usually 0 for write, unless overwriting
-            addedLines = this.extractNonEmptyLines(newContent);
+            const stats = this.calculateDiffStats(oldContent, newContent);
+            linesAdded = stats.added;
+            linesRemoved = stats.removed;
+            if (oldContent && newContent) {
+                addedLines = this.diffAddedLines(oldContent, newContent);
+            }
+            else {
+                addedLines = this.extractNonEmptyLines(newContent);
+            }
         }
         else if (editOps.includes(funcName)) {
             // Use LCS for edits to be accurate

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;
@@ -160,9 +162,10 @@ export class OpencodeScanner extends BaseScanner {
                 : 'modify';
         // Use opencode's provided diff stats if available (most accurate)
         // additions/deletions are pre-calculated by opencode
+        const diffStats = this.diffLineCounts(beforeContent, afterContent);
         const addedLines = this.diffAddedLines(beforeContent, afterContent);
-        const linesAdded = typeof diff.additions === 'number' ? diff.additions : addedLines.length;
-        const linesRemoved = typeof diff.deletions === 'number' ? diff.deletions : 0;
+        const linesAdded = typeof diff.additions === 'number' ? diff.additions : diffStats.added;
+        const linesRemoved = typeof diff.deletions === 'number' ? diff.deletions : diffStats.removed;
         return {
             filePath,
             linesAdded,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-credit",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "CLI tool to track and analyze AI coding assistants' contributions in your codebase",
   "main": "dist/index.js",
   "type": "module",
@@ -11,7 +11,10 @@
     "build": "tsc",
     "start": "node dist/cli.js",
     "dev": "tsc && node dist/cli.js",
-    "pub": "npm run build && npm publish",
+    "v-patch": "npm version patch",
+    "v-minor": "npm version minor",
+    "v-major": "npm version major",
+    "pub": "npm run build && npm publish --access public",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -37,7 +40,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",