ai-credit 1.0.0

package/dist/scanners/gemini.d.ts

@@ -0,0 +1,35 @@
+import { AISession, AITool } from '../types.js';
+import { BaseScanner } from './base.js';
+/**
+ * Scanner for Gemini CLI sessions
+ *
+ * Gemini CLI stores session data in:
+ * ~/.gemini/tmp/<project_hash>/chats/*.json
+ * or ~/.gemini/history/*.json
+ *
+ * Each JSON file contains a complete conversation with messages
+ * that include functionCall objects for file operations.
+ */
+export declare class GeminiScanner extends BaseScanner {
+    get tool(): AITool;
+    get storagePath(): string;
+    /**
+     * Hash project path to match Gemini's directory naming
+     */
+    private hashProjectPath;
+    scan(projectPath: string): AISession[];
+    parseSessionFile(filePath: string, projectPath: string): AISession | null;
+    /**
+     * Check if two paths match or are related
+     */
+    private pathsMatch;
+    /**
+     * Parse a functionCall object to extract file changes
+     */
+    private parseFunctionCall;
+    /**
+     * Calculate lines added and removed using simple diff (LCS)
+     */
+    private calculateDiffStats;
+    private computeLCS;
+}

package/dist/scanners/gemini.js

@@ -0,0 +1,318 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { glob } from 'glob';
+import { AITool } from '../types.js';
+import { BaseScanner } from './base.js';
+/**
+ * Scanner for Gemini CLI sessions
+ *
+ * Gemini CLI stores session data in:
+ * ~/.gemini/tmp/<project_hash>/chats/*.json
+ * or ~/.gemini/history/*.json
+ *
+ * Each JSON file contains a complete conversation with messages
+ * that include functionCall objects for file operations.
+ */
+export class GeminiScanner extends BaseScanner {
+    get tool() {
+        return AITool.GEMINI;
+    }
+    get storagePath() {
+        return '~/.gemini';
+    }
+    /**
+     * Hash project path to match Gemini's directory naming
+     */
+    hashProjectPath(projectPath) {
+        return crypto.createHash('md5').update(projectPath).digest('hex').substring(0, 16);
+    }
+    scan(projectPath) {
+        const sessions = [];
+        const basePath = this.resolveStoragePath();
+        if (!fs.existsSync(basePath)) {
+            return sessions;
+        }
+        const possibleDirs = [];
+        // Check tmp directory structure
+        const tmpDir = path.join(basePath, 'tmp');
+        if (fs.existsSync(tmpDir)) {
+            try {
+                const allDirs = fs.readdirSync(tmpDir);
+                for (const dir of allDirs) {
+                    const fullDir = path.join(tmpDir, dir);
+                    if (fs.statSync(fullDir).isDirectory()) {
+                        // Check for chats subdirectory
+                        const chatsDir = path.join(fullDir, 'chats');
+                        if (fs.existsSync(chatsDir)) {
+                            possibleDirs.push(chatsDir);
+                        }
+                        // Also check the directory itself for JSON files
+                        possibleDirs.push(fullDir);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        // Also check history directory
+        const historyDir = path.join(basePath, 'history');
+        if (fs.existsSync(historyDir)) {
+            possibleDirs.push(historyDir);
+        }
+        // Check sessions directory
+        const sessionsDir = path.join(basePath, 'sessions');
+        if (fs.existsSync(sessionsDir)) {
+            possibleDirs.push(sessionsDir);
+        }
+        for (const dir of possibleDirs) {
+            try {
+                const files = glob.sync('*.json', { cwd: dir });
+                for (const file of files) {
+                    const session = this.parseSessionFile(path.join(dir, file), projectPath);
+                    if (session && session.changes.length > 0) {
+                        sessions.push(session);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return sessions;
+    }
+    parseSessionFile(filePath, projectPath) {
+        const data = this.readJsonFile(filePath);
+        if (!data)
+            return null;
+        const changes = [];
+        let sessionTimestamp = null;
+        let sessionProjectPath = null;
+        // Extract metadata from various possible fields
+        if (data.created_at) {
+            sessionTimestamp = new Date(data.created_at);
+        }
+        else if (data.timestamp) {
+            sessionTimestamp = new Date(data.timestamp);
+        }
+        else if (data.startTime) {
+            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
+        if (sessionProjectPath) {
+            const normalizedSessionPath = path.resolve(sessionProjectPath);
+            const normalizedProjectPath = path.resolve(projectPath);
+            if (!this.pathsMatch(normalizedSessionPath, normalizedProjectPath)) {
+                return null;
+            }
+        }
+        // Extract model if available (check root or messages)
+        let sessionModel = data.model || data.defaultModel;
+        if (!sessionModel && data.messages) {
+            for (const msg of data.messages) {
+                if (msg.model) {
+                    sessionModel = msg.model;
+                    break;
+                }
+            }
+        }
+        // Parse messages from various possible structures
+        const messages = data.messages || data.turns || data.conversation || data.history || [];
+        for (const message of messages) {
+            // Check for assistant/model role
+            const role = message.role || message.type;
+            if (['assistant', 'model', 'ASSISTANT', 'gemini'].includes(role)) {
+                const messageTimestamp = message.timestamp ? new Date(message.timestamp) : sessionTimestamp;
+                const parts = message.parts || message.content || message.text || [];
+                const partsArray = Array.isArray(parts) ? parts : [parts];
+                for (const part of partsArray) {
+                    // Check for function calls in various formats
+                    if (part.functionCall) {
+                        const change = this.parseFunctionCall(part.functionCall, projectPath, messageTimestamp, sessionModel);
+                        if (change) {
+                            changes.push(change);
+                        }
+                    }
+                    // Also check for tool_use format (similar to Claude)
+                    if (part.type === 'tool_use' || part.type === 'function_call') {
+                        const change = this.parseFunctionCall({
+                            name: part.name,
+                            args: part.input || part.args || part.arguments
+                        }, projectPath, messageTimestamp, sessionModel);
+                        if (change) {
+                            changes.push(change);
+                        }
+                    }
+                }
+            }
+            // Also check for tool_calls array format (snake_case)
+            if (message.tool_calls && Array.isArray(message.tool_calls)) {
+                const messageTimestamp = message.timestamp ? new Date(message.timestamp) : sessionTimestamp;
+                for (const toolCall of message.tool_calls) {
+                    const func = toolCall.function || toolCall;
+                    const change = this.parseFunctionCall({
+                        name: func.name,
+                        args: typeof func.arguments === 'string' ? JSON.parse(func.arguments) : func.arguments
+                    }, projectPath, messageTimestamp, sessionModel);
+                    if (change) {
+                        changes.push(change);
+                    }
+                }
+            }
+            // Check for toolCalls array format (camelCase - common in some Gemini versions)
+            if (message.toolCalls && Array.isArray(message.toolCalls)) {
+                const messageTimestamp = message.timestamp ? new Date(message.timestamp) : sessionTimestamp;
+                for (const toolCall of message.toolCalls) {
+                    const change = this.parseFunctionCall({
+                        name: toolCall.name,
+                        args: toolCall.args
+                    }, projectPath, messageTimestamp, sessionModel);
+                    if (change) {
+                        changes.push(change);
+                    }
+                }
+            }
+        }
+        if (changes.length === 0)
+            return null;
+        return {
+            id: this.generateSessionId(filePath),
+            tool: this.tool,
+            timestamp: sessionTimestamp || new Date(),
+            projectPath,
+            changes,
+            totalFilesChanged: new Set(changes.map(c => c.filePath)).size,
+            totalLinesAdded: changes.reduce((sum, c) => sum + c.linesAdded, 0),
+            totalLinesRemoved: changes.reduce((sum, c) => sum + c.linesRemoved, 0),
+            model: sessionModel,
+        };
+    }
+    /**
+     * 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))
+            return true;
+        // Same basename (project name)
+        if (path.basename(path1) === path.basename(path2))
+            return true;
+        return false;
+    }
+    /**
+     * Parse a functionCall object to extract file changes
+     */
+    parseFunctionCall(funcCall, projectPath, timestamp, model) {
+        if (!funcCall)
+            return null;
+        const funcName = (funcCall.name || '').toLowerCase();
+        const args = funcCall.args || funcCall.arguments || {};
+        // Supported operations - expanded list
+        const writeOps = ['write_file', 'create_file', 'write', 'save_file', 'create', 'writefile'];
+        const editOps = ['edit_file', 'update_file', 'modify_file', 'replace_in_file', 'edit', 'patch', 'apply_diff', 'replace'];
+        // Try various field names for file path
+        let filePath = args.path || args.file_path || args.filename || args.file || args.target || '';
+        let newContent = args.content || args.newContent || args.text || args.code || args.data || args.new_string || args.new_str || '';
+        let oldContent = args.oldContent || args.original || args.old_content || args.old_string || args.old_str || '';
+        if (!filePath)
+            return null;
+        // Normalize path
+        filePath = this.normalizePath(filePath, projectPath);
+        const changeType = (!oldContent && newContent) ? 'create'
+            : (oldContent && !newContent) ? 'delete'
+                : 'modify';
+        // Calculate diff stats
+        let linesAdded = 0;
+        let linesRemoved = 0;
+        if (writeOps.includes(funcName)) {
+            linesAdded = this.countLines(newContent);
+            linesRemoved = this.countLines(oldContent); // Usually 0 for write, unless overwriting
+        }
+        else if (editOps.includes(funcName)) {
+            // Use LCS for edits to be accurate
+            const stats = this.calculateDiffStats(oldContent, newContent);
+            linesAdded = stats.added;
+            linesRemoved = stats.removed;
+        }
+        else {
+            if (newContent) {
+                linesAdded = this.countLines(newContent);
+            }
+        }
+        if (linesAdded === 0 && linesRemoved === 0)
+            return null;
+        return {
+            filePath,
+            linesAdded,
+            linesRemoved,
+            changeType: writeOps.includes(funcName) && !oldContent ? 'create' : 'modify',
+            timestamp: timestamp || new Date(),
+            tool: this.tool,
+            content: newContent,
+            model,
+        };
+    }
+    /**
+     * Calculate lines added and removed using simple diff (LCS)
+     */
+    calculateDiffStats(before, after) {
+        if (!before)
+            return { added: this.countLines(after), removed: 0 };
+        if (!after)
+            return { added: 0, removed: this.countLines(before) };
+        const beforeLines = before.split(/\r?\n/);
+        const afterLines = after.split(/\r?\n/);
+        // Optimization: trim matching start
+        let start = 0;
+        while (start < beforeLines.length && start < afterLines.length && beforeLines[start] === afterLines[start]) {
+            start++;
+        }
+        // Optimization: trim matching end
+        let endBefore = beforeLines.length - 1;
+        let endAfter = afterLines.length - 1;
+        while (endBefore >= start && endAfter >= start && beforeLines[endBefore] === afterLines[endAfter]) {
+            endBefore--;
+            endAfter--;
+        }
+        const remainingBefore = beforeLines.slice(start, endBefore + 1);
+        const remainingAfter = afterLines.slice(start, endAfter + 1);
+        // If nothing remaining, no changes
+        if (remainingBefore.length === 0 && remainingAfter.length === 0) {
+            return { added: 0, removed: 0 };
+        }
+        // Calculate LCS on the remaining parts
+        const lcs = this.computeLCS(remainingBefore, remainingAfter);
+        return {
+            added: remainingAfter.length - lcs,
+            removed: remainingBefore.length - lcs
+        };
+    }
+    computeLCS(lines1, lines2) {
+        const m = lines1.length;
+        const n = lines2.length;
+        // Use two rows for O(min(M,N)) space
+        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 (lines1[i - 1] === lines2[j - 1]) {
+                    curr[j] = prev[j - 1] + 1;
+                }
+                else {
+                    curr[j] = Math.max(prev[j], curr[j - 1]);
+                }
+            }
+            // Swap references
+            const temp = prev;
+            prev = curr;
+            curr = temp;
+        }
+        return prev[n];
+    }
+}

package/dist/scanners/index.d.ts

@@ -0,0 +1,6 @@
+export { BaseScanner } from './base.js';
+export { ClaudeScanner } from './claude.js';
+export { CodexScanner } from './codex.js';
+export { GeminiScanner } from './gemini.js';
+export { AiderScanner } from './aider.js';
+export { OpencodeScanner } from './opencode.js';

package/dist/scanners/index.js

@@ -0,0 +1,6 @@
+export { BaseScanner } from './base.js';
+export { ClaudeScanner } from './claude.js';
+export { CodexScanner } from './codex.js';
+export { GeminiScanner } from './gemini.js';
+export { AiderScanner } from './aider.js';
+export { OpencodeScanner } from './opencode.js';

package/dist/scanners/opencode.d.ts

@@ -0,0 +1,40 @@
+import { AISession, AITool } from '../types.js';
+import { BaseScanner } from './base.js';
+/**
+ * Scanner for Opencode (opencode.ai) sessions
+ *
+ * Opencode stores session data in:
+ * ~/.local/share/opencode/storage/
+ *
+ * Structure:
+ * - storage/session/ - session metadata files (named by session ID)
+ * - storage/message/ - individual message files with file change diffs
+ * - storage/part/ - message parts
+ *
+ * File changes are recorded in message.info.summary.diffs with:
+ * - file: relative file path
+ * - before: previous content
+ * - after: new content
+ */
+export declare class OpencodeScanner extends BaseScanner {
+    get tool(): AITool;
+    get storagePath(): string;
+    scan(projectPath: string): AISession[];
+    parseSessionFile(filePath: string, projectPath: string): AISession | null;
+    /**
+     * Check if two paths match (session belongs to project)
+     */
+    private pathsMatch;
+    /**
+     * Parse a diff object to extract file change
+     */
+    private parseDiff;
+    /**
+     * Parse message data for file changes
+     */
+    private parseMessageChanges;
+    /**
+     * Remove duplicate file changes
+     */
+    private deduplicateChanges;
+}

package/dist/scanners/opencode.js

@@ -0,0 +1,210 @@
+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 Opencode (opencode.ai) sessions
+ *
+ * Opencode stores session data in:
+ * ~/.local/share/opencode/storage/
+ *
+ * Structure:
+ * - storage/session/ - session metadata files (named by session ID)
+ * - storage/message/ - individual message files with file change diffs
+ * - storage/part/ - message parts
+ *
+ * File changes are recorded in message.info.summary.diffs with:
+ * - file: relative file path
+ * - before: previous content
+ * - after: new content
+ */
+export class OpencodeScanner extends BaseScanner {
+    get tool() {
+        return AITool.OPENCODE;
+    }
+    get storagePath() {
+        return '~/.local/share/opencode';
+    }
+    scan(projectPath) {
+        const sessions = [];
+        const basePath = this.resolveStoragePath();
+        if (!fs.existsSync(basePath)) {
+            return sessions;
+        }
+        const sessionDir = path.join(basePath, 'storage', 'session');
+        if (!fs.existsSync(sessionDir)) {
+            return sessions;
+        }
+        try {
+            // Find all session files recursively (they are in subdirectories by project hash)
+            const sessionFiles = glob.sync('**/*.json', { cwd: sessionDir });
+            for (const file of sessionFiles) {
+                const session = this.parseSessionFile(path.join(sessionDir, file), projectPath);
+                if (session && session.changes.length > 0) {
+                    sessions.push(session);
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return sessions;
+    }
+    parseSessionFile(filePath, projectPath) {
+        const sessionData = this.readJsonFile(filePath);
+        if (!sessionData)
+            return null;
+        const basePath = this.resolveStoragePath();
+        // Extract session info
+        const sessionId = sessionData.id || path.basename(filePath, '.json');
+        const sessionProjectPath = sessionData.directory || sessionData.projectPath || null;
+        const sessionTimestamp = sessionData.time?.created
+            ? new Date(sessionData.time.created)
+            : new Date();
+        // Filter by project path
+        if (sessionProjectPath) {
+            const normalizedSessionPath = path.resolve(sessionProjectPath);
+            const normalizedProjectPath = path.resolve(projectPath);
+            if (!this.pathsMatch(normalizedSessionPath, normalizedProjectPath)) {
+                return null;
+            }
+        }
+        // Parse file changes from messages
+        const changes = [];
+        let sessionModel;
+        // First, try to parse individual message files if available (more granular)
+        const messageDir = path.join(basePath, 'storage', 'message');
+        if (fs.existsSync(messageDir) && sessionData.id) {
+            try {
+                // Messages are stored in subdirectories by session ID
+                const sessionMessageDir = path.join(messageDir, sessionData.id);
+                if (fs.existsSync(sessionMessageDir)) {
+                    const messageFiles = glob.sync('*.json', { cwd: sessionMessageDir });
+                    for (const msgFile of messageFiles) {
+                        const msgData = this.readJsonFile(path.join(sessionMessageDir, msgFile));
+                        if (msgData?.sessionID === sessionData.id) {
+                            // Extract model from message
+                            const msgModel = msgData.model?.modelID;
+                            if (msgModel && !sessionModel) {
+                                sessionModel = msgModel;
+                            }
+                            const msgChanges = this.parseMessageChanges(msgData, projectPath, msgModel);
+                            changes.push(...msgChanges);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        // If no changes found in messages, fall back to session summary
+        if (changes.length === 0 && sessionData.summary?.diffs && Array.isArray(sessionData.summary.diffs)) {
+            for (const diff of sessionData.summary.diffs) {
+                const change = this.parseDiff(diff, projectPath, sessionTimestamp, sessionModel);
+                if (change) {
+                    changes.push(change);
+                }
+            }
+        }
+        if (changes.length === 0)
+            return null;
+        // Remove duplicate changes (same file, same content)
+        const uniqueChanges = this.deduplicateChanges(changes);
+        // Update all changes with the session model if found
+        if (sessionModel) {
+            for (const change of uniqueChanges) {
+                if (!change.model) {
+                    change.model = sessionModel;
+                }
+            }
+        }
+        return {
+            id: sessionId,
+            tool: this.tool,
+            model: sessionModel,
+            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),
+        };
+    }
+    /**
+     * Check if two paths match (session belongs to project)
+     */
+    pathsMatch(sessionPath, projectPath) {
+        if (sessionPath === projectPath)
+            return true;
+        if (sessionPath.startsWith(projectPath + path.sep))
+            return true;
+        if (projectPath.startsWith(sessionPath + path.sep))
+            return true;
+        if (path.basename(sessionPath) === path.basename(projectPath))
+            return true;
+        return false;
+    }
+    /**
+     * Parse a diff object to extract file change
+     */
+    parseDiff(diff, projectPath, timestamp, model) {
+        if (!diff || !diff.file)
+            return null;
+        const filePath = this.normalizePath(diff.file, projectPath);
+        const beforeContent = diff.before || '';
+        const afterContent = diff.after || '';
+        const changeType = (!beforeContent && afterContent) ? 'create'
+            : (beforeContent && !afterContent) ? 'delete'
+                : 'modify';
+        // Use opencode's provided diff stats if available (most accurate)
+        // additions/deletions are pre-calculated by opencode
+        const linesAdded = typeof diff.additions === 'number' ? diff.additions : 0;
+        const linesRemoved = typeof diff.deletions === 'number' ? diff.deletions : 0;
+        return {
+            filePath,
+            linesAdded,
+            linesRemoved,
+            changeType,
+            timestamp,
+            tool: this.tool,
+            model,
+            content: afterContent,
+        };
+    }
+    /**
+     * Parse message data for file changes
+     */
+    parseMessageChanges(msgData, projectPath, model) {
+        const changes = [];
+        const timestamp = msgData.time?.created
+            ? new Date(msgData.time.created)
+            : new Date();
+        const diffs = msgData.summary?.diffs;
+        if (diffs && Array.isArray(diffs)) {
+            for (const diff of diffs) {
+                const change = this.parseDiff(diff, projectPath, timestamp, model);
+                if (change) {
+                    changes.push(change);
+                }
+            }
+        }
+        return changes;
+    }
+    /**
+     * Remove duplicate file changes
+     */
+    deduplicateChanges(changes) {
+        const seen = new Set();
+        const unique = [];
+        for (const change of changes) {
+            const key = `${change.filePath}-${change.linesAdded}-${change.linesRemoved}-${change.timestamp.getTime()}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                unique.push(change);
+            }
+        }
+        return unique;
+    }
+}