ai-credit 1.0.4 → 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 (macOS/Linux). 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 (macOS/Linux)
+- 🔍 **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
@@ -274,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.
@@ -340,6 +382,7 @@ This methodology ensures that:
 - 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/scanners/aider.d.ts

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,205 @@
+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');
+    }
+}

package/dist/scanners/base.d.ts

@@ -45,6 +45,13 @@ 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
      */

package/dist/scanners/base.js

@@ -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
      */

package/dist/scanners/claude.js

@@ -187,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.js

@@ -316,14 +316,19 @@ export class CodexScanner extends BaseScanner {
         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;
@@ -331,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);
             }
         }

package/dist/scanners/gemini.js

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

@@ -162,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.4",
+  "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 version patch && npm run build && npm publish --access public",
+    "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": [