ai-credit 1.0.0

package/dist/analyzer.js

@@ -0,0 +1,357 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+import { AITool, } from './types.js';
+import { ClaudeScanner, CodexScanner, GeminiScanner, AiderScanner, OpencodeScanner, } from './scanners/index.js';
+/**
+ * Main analyzer that coordinates all scanners and computes statistics
+ */
+export class ContributionAnalyzer {
+    projectPath;
+    scanners;
+    constructor(projectPath) {
+        this.projectPath = path.resolve(projectPath);
+        this.scanners = [
+            new ClaudeScanner(),
+            new CodexScanner(),
+            new GeminiScanner(),
+            new AiderScanner(),
+            new OpencodeScanner(),
+        ];
+    }
+    /**
+     * Get list of available AI tools
+     */
+    getAvailableTools() {
+        const available = [];
+        for (const scanner of this.scanners) {
+            if (scanner.isAvailable()) {
+                available.push(scanner.tool);
+            }
+        }
+        // Special check for Aider (project-local)
+        const aiderScanner = this.scanners.find(s => s.tool === AITool.AIDER);
+        if (aiderScanner?.isAvailableForProject(this.projectPath)) {
+            if (!available.includes(AITool.AIDER)) {
+                available.push(AITool.AIDER);
+            }
+        }
+        return available;
+    }
+    /**
+     * Scan all sessions from all tools
+     */
+    scanAllSessions(tools) {
+        const sessions = [];
+        for (const scanner of this.scanners) {
+            if (tools && !tools.includes(scanner.tool)) {
+                continue;
+            }
+            try {
+                const toolSessions = scanner.scan(this.projectPath);
+                sessions.push(...toolSessions);
+            }
+            catch (error) {
+                // Silently ignore scanner errors
+            }
+        }
+        // Sort by timestamp
+        sessions.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+        return sessions;
+    }
+    /**
+     * Analyze the repository and compute contribution statistics
+     */
+    analyze(tools) {
+        const sessions = this.scanAllSessions(tools);
+        // Get repository file stats
+        const repoFiles = this.getRepoFiles();
+        const totalLines = this.countTotalLines(repoFiles);
+        // Compute statistics
+        const byTool = this.computeToolStats(sessions);
+        const byFile = this.computeFileStats(sessions, repoFiles);
+        // Count AI-touched files and lines (only count files that exist in repo)
+        let aiTouchedFiles = 0;
+        let aiContributedLines = 0;
+        for (const [, stats] of byFile) {
+            if (stats.aiContributedLines > 0) {
+                aiTouchedFiles++;
+                aiContributedLines += stats.aiContributedLines;
+                // Aggregate verified lines to ToolStats and ModelStats
+                for (const [tool, count] of stats.contributions) {
+                    const toolStats = byTool.get(tool);
+                    if (toolStats) {
+                        toolStats.verifiedLines += count;
+                        // Distribute verified lines to models based on their activity share
+                        if (toolStats.linesAdded > 0) {
+                            for (const [, modelStats] of toolStats.byModel) {
+                                const ratio = modelStats.linesAdded / toolStats.linesAdded;
+                                modelStats.verifiedLines += Math.round(count * ratio);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            repoPath: this.projectPath,
+            scanTime: new Date(),
+            totalFiles: repoFiles.length,
+            totalLines,
+            aiTouchedFiles,
+            aiContributedLines,
+            sessions,
+            byTool,
+            byFile,
+        };
+    }
+    /**
+     * Get all files in the repository (excluding common ignore patterns)
+     */
+    getRepoFiles() {
+        const ignorePatterns = [
+            '**/node_modules/**',
+            '**/.git/**',
+            '**/dist/**',
+            '**/build/**',
+            '**/__pycache__/**',
+            '**/*.pyc',
+            '**/venv/**',
+            '**/.venv/**',
+            '**/coverage/**',
+            '**/.next/**',
+            '**/.nuxt/**',
+            '**/package-lock.json',
+            '**/pnpm-lock.yaml',
+            '**/yarn.lock',
+        ];
+        try {
+            const files = glob.sync('**/*', {
+                cwd: this.projectPath,
+                nodir: true,
+                ignore: ignorePatterns,
+            });
+            // Filter to only include text files
+            return files.filter(file => {
+                const ext = path.extname(file).toLowerCase();
+                const textExtensions = [
+                    '.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs',
+                    '.py', '.rb', '.go', '.rs', '.java', '.kt', '.scala',
+                    '.c', '.cpp', '.h', '.hpp', '.cs',
+                    '.html', '.css', '.scss', '.less', '.sass',
+                    '.json', '.yaml', '.yml', '.toml', '.xml',
+                    '.md', '.txt', '.rst',
+                    '.sh', '.bash', '.zsh', '.fish',
+                    '.sql', '.graphql',
+                    '.vue', '.svelte',
+                    '.php', '.swift', '.m',
+                    '.r', '.R', '.jl',
+                    '.ex', '.exs', '.erl', '.hrl',
+                    '.hs', '.elm', '.clj', '.cljs',
+                    '.dockerfile', '.tf', '.hcl',
+                ];
+                return textExtensions.includes(ext) || !ext;
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Count total lines in all repository files
+     */
+    countTotalLines(files) {
+        let total = 0;
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(this.projectPath, file), 'utf-8');
+                total += content.split('\n').length;
+            }
+            catch {
+                // Ignore unreadable files
+            }
+        }
+        return total;
+    }
+    /**
+     * Compute statistics by AI tool
+     */
+    computeToolStats(sessions) {
+        const stats = new Map();
+        // Track unique files per tool across all sessions
+        const filesByTool = new Map();
+        // Track unique files per model across all sessions
+        const filesByModel = new Map();
+        for (const session of sessions) {
+            let toolStats = stats.get(session.tool);
+            if (!toolStats) {
+                toolStats = {
+                    tool: session.tool,
+                    sessionsCount: 0,
+                    filesCreated: 0,
+                    filesModified: 0,
+                    totalFiles: 0,
+                    linesAdded: 0,
+                    linesRemoved: 0,
+                    netLines: 0,
+                    verifiedLines: 0,
+                    byModel: new Map(),
+                };
+                stats.set(session.tool, toolStats);
+                filesByTool.set(session.tool, new Set());
+            }
+            toolStats.sessionsCount++;
+            const toolFiles = filesByTool.get(session.tool);
+            for (const change of session.changes) {
+                toolFiles.add(change.filePath);
+                toolStats.linesAdded += change.linesAdded;
+                toolStats.linesRemoved += change.linesRemoved;
+                if (change.changeType === 'create') {
+                    toolStats.filesCreated++;
+                }
+                else {
+                    toolStats.filesModified++;
+                }
+                // Aggregate by model
+                const modelName = change.model || session.model || 'unknown';
+                let modelStats = toolStats.byModel.get(modelName);
+                if (!modelStats) {
+                    modelStats = {
+                        model: modelName,
+                        sessionsCount: 0,
+                        filesCreated: 0,
+                        filesModified: 0,
+                        totalFiles: 0,
+                        linesAdded: 0,
+                        linesRemoved: 0,
+                        netLines: 0,
+                        verifiedLines: 0,
+                    };
+                    toolStats.byModel.set(modelName, modelStats);
+                    filesByModel.set(`${session.tool}:${modelName}`, new Set());
+                }
+                const modelFiles = filesByModel.get(`${session.tool}:${modelName}`);
+                modelFiles.add(change.filePath);
+                modelStats.linesAdded += change.linesAdded;
+                modelStats.linesRemoved += change.linesRemoved;
+                if (change.changeType === 'create') {
+                    modelStats.filesCreated++;
+                }
+                else {
+                    modelStats.filesModified++;
+                }
+            }
+            // Count sessions per model
+            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);
+                if (modelStats) {
+                    modelStats.sessionsCount++;
+                }
+            }
+        }
+        // Update totalFiles with unique count
+        for (const [tool, toolStats] of stats) {
+            toolStats.totalFiles = filesByTool.get(tool)?.size || 0;
+            toolStats.netLines = toolStats.linesAdded - toolStats.linesRemoved;
+            for (const [modelName, modelStats] of toolStats.byModel) {
+                modelStats.totalFiles = filesByModel.get(`${tool}:${modelName}`)?.size || 0;
+                modelStats.netLines = modelStats.linesAdded - modelStats.linesRemoved;
+            }
+        }
+        return stats;
+    }
+    /**
+     * Compute statistics by file using Verified Existence logic
+     */
+    computeFileStats(sessions, repoFiles) {
+        const stats = new Map();
+        // 1. Group changes by file
+        const fileChanges = new Map();
+        for (const session of sessions) {
+            for (const change of session.changes) {
+                if (!fileChanges.has(change.filePath)) {
+                    fileChanges.set(change.filePath, []);
+                }
+                fileChanges.get(change.filePath).push(change);
+            }
+        }
+        // 2. Process each file in the repository
+        for (const filePath of repoFiles) {
+            const fullPath = path.join(this.projectPath, filePath);
+            let content = '';
+            try {
+                content = fs.readFileSync(fullPath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const fileLines = content.split('\n');
+            const totalLines = fileLines.length;
+            // Track which lines in current file are accounted for (claimed)
+            // We use exact string matching on trimmed lines.
+            const contentMap = new Map();
+            for (let i = 0; i < totalLines; i++) {
+                const line = fileLines[i].trim();
+                if (!line)
+                    continue; // Skip empty lines for matching
+                if (!contentMap.has(line)) {
+                    contentMap.set(line, []);
+                }
+                contentMap.get(line).push(i);
+            }
+            const claimedIndices = new Set();
+            const contributions = new Map();
+            // Get changes for this file
+            const changes = fileChanges.get(filePath) || [];
+            // Sort changes: Newest First (Reverse Chronological)
+            // This ensures the most recent author gets credit for a line
+            changes.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+            let aiContributedCount = 0;
+            for (const change of changes) {
+                if (!change.content)
+                    continue;
+                const changeLines = change.content.split('\n');
+                let matchedForThisChange = 0;
+                for (const line of changeLines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    const indices = contentMap.get(trimmed);
+                    if (indices) {
+                        // Find the first unclaimed index for this content
+                        for (const idx of indices) {
+                            if (!claimedIndices.has(idx)) {
+                                claimedIndices.add(idx);
+                                matchedForThisChange++;
+                                // Line is claimed by this tool
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (matchedForThisChange > 0) {
+                    aiContributedCount += matchedForThisChange;
+                    const toolTotal = contributions.get(change.tool) || 0;
+                    contributions.set(change.tool, toolTotal + matchedForThisChange);
+                }
+            }
+            stats.set(filePath, {
+                filePath,
+                totalLines,
+                aiContributedLines: aiContributedCount,
+                aiContributionRatio: totalLines > 0 ? aiContributedCount / totalLines : 0,
+                contributions,
+            });
+        }
+        return stats;
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};