ai-credit 1.0.0

package/dist/scanners/base.js

@@ -0,0 +1,88 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+/**
+ * Base class for AI tool scanners
+ */
+export class BaseScanner {
+    homeDir;
+    constructor() {
+        this.homeDir = os.homedir();
+    }
+    /**
+     * Check if this tool has data available
+     */
+    isAvailable() {
+        const fullPath = this.resolveStoragePath();
+        return fs.existsSync(fullPath);
+    }
+    /**
+     * Resolve the full storage path
+     */
+    resolveStoragePath() {
+        return this.storagePath.replace('~', this.homeDir);
+    }
+    /**
+     * Count lines in a string
+     */
+    countLines(content) {
+        if (!content)
+            return 0;
+        return content.split('\n').filter(line => line.length > 0).length;
+    }
+    /**
+     * Normalize file path relative to project
+     */
+    normalizePath(filePath, projectPath) {
+        if (path.isAbsolute(filePath)) {
+            return path.relative(projectPath, filePath);
+        }
+        return filePath;
+    }
+    /**
+     * Check if a file path belongs to the project
+     */
+    isProjectFile(filePath, projectPath) {
+        const normalizedPath = this.normalizePath(filePath, projectPath);
+        // Exclude paths that go outside the project
+        return !normalizedPath.startsWith('..');
+    }
+    /**
+     * Read and parse JSON file safely
+     */
+    readJsonFile(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Read and parse JSONL file safely
+     */
+    readJsonlFile(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n').filter(line => line.trim());
+            return lines.map(line => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return null;
+                }
+            }).filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Generate a unique session ID
+     */
+    generateSessionId(filePath) {
+        return `${this.tool}-${path.basename(filePath, path.extname(filePath))}`;
+    }
+}

package/dist/scanners/claude.d.ts

@@ -0,0 +1,30 @@
+import { AISession, AITool } from '../types.js';
+import { BaseScanner } from './base.js';
+/**
+ * Scanner for Claude Code sessions
+ *
+ * Claude Code stores session data in:
+ * ~/.claude/projects/<path-encoded-project-name>/*.jsonl
+ *
+ * Each JSONL file contains conversation turns with tool_use blocks
+ * that record file operations (write, edit, etc.)
+ */
+export declare class ClaudeScanner extends BaseScanner {
+    get tool(): AITool;
+    get storagePath(): string;
+    /**
+     * Encode project path to match Claude's directory naming convention
+     * Claude encodes paths by replacing / with -
+     */
+    private encodeProjectPath;
+    /**
+     * Decode Claude's directory name back to a path
+     */
+    private decodeProjectPath;
+    scan(projectPath: string): AISession[];
+    parseSessionFile(filePath: string, projectPath: string): AISession | null;
+    /**
+     * Parse a tool_use block to extract file changes
+     */
+    private parseToolUse;
+}

package/dist/scanners/claude.js

@@ -0,0 +1,203 @@
+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 Claude Code sessions
+ *
+ * Claude Code stores session data in:
+ * ~/.claude/projects/<path-encoded-project-name>/*.jsonl
+ *
+ * Each JSONL file contains conversation turns with tool_use blocks
+ * that record file operations (write, edit, etc.)
+ */
+export class ClaudeScanner extends BaseScanner {
+    get tool() {
+        return AITool.CLAUDE_CODE;
+    }
+    get storagePath() {
+        return '~/.claude/projects';
+    }
+    /**
+     * Encode project path to match Claude's directory naming convention
+     * Claude encodes paths by replacing / with -
+     */
+    encodeProjectPath(projectPath) {
+        return projectPath.replace(/\//g, '-').replace(/^-/, '');
+    }
+    /**
+     * Decode Claude's directory name back to a path
+     */
+    decodeProjectPath(encodedPath) {
+        return '/' + encodedPath.replace(/-/g, '/');
+    }
+    scan(projectPath) {
+        const sessions = [];
+        const basePath = this.resolveStoragePath();
+        if (!fs.existsSync(basePath)) {
+            return sessions;
+        }
+        // Try to find the project directory
+        const encodedPath = this.encodeProjectPath(projectPath);
+        const projectDir = path.join(basePath, encodedPath);
+        const projectBasename = path.basename(projectPath);
+        // Collect all possible matching directories
+        const possibleDirs = new Set();
+        // Add exact match
+        if (fs.existsSync(projectDir)) {
+            possibleDirs.add(projectDir);
+        }
+        // Scan all directories to find matches
+        try {
+            const allDirs = fs.readdirSync(basePath);
+            for (const dir of allDirs) {
+                const fullDir = path.join(basePath, dir);
+                if (!fs.statSync(fullDir).isDirectory())
+                    continue;
+                // Check various matching criteria
+                const decodedPath = this.decodeProjectPath(dir);
+                // Match by:
+                // 1. Directory name contains project basename
+                // 2. Decoded path ends with project path
+                // 3. Project path ends with decoded path
+                // 4. Same basename
+                if (dir.includes(projectBasename) ||
+                    dir.toLowerCase().includes(projectBasename.toLowerCase()) ||
+                    decodedPath.endsWith(projectPath) ||
+                    projectPath.endsWith(decodedPath.slice(1)) ||
+                    path.basename(decodedPath) === projectBasename) {
+                    possibleDirs.add(fullDir);
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        // Parse all session files from matching directories
+        for (const dir of possibleDirs) {
+            try {
+                const files = glob.sync('*.jsonl', { 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 entries = this.readJsonlFile(filePath);
+        if (entries.length === 0)
+            return null;
+        const changes = [];
+        let sessionTimestamp = null;
+        let sessionModel = undefined;
+        for (const entry of entries) {
+            // Extract timestamp from various possible fields
+            if (!sessionTimestamp) {
+                if (entry.timestamp) {
+                    sessionTimestamp = new Date(entry.timestamp);
+                }
+                else if (entry.created_at) {
+                    sessionTimestamp = new Date(entry.created_at);
+                }
+            }
+            // Extract model (try entry.model or entry.message.model)
+            if (!sessionModel) {
+                if (entry.model) {
+                    sessionModel = entry.model;
+                }
+                else if (entry.message && entry.message.model) {
+                    sessionModel = entry.message.model;
+                }
+            }
+            // Look for assistant messages with tool_use
+            if (entry.type === 'assistant' && entry.message?.content) {
+                const content = Array.isArray(entry.message.content)
+                    ? entry.message.content
+                    : [entry.message.content];
+                for (const block of content) {
+                    if (block.type === 'tool_use') {
+                        const change = this.parseToolUse(block, projectPath, entry.timestamp, sessionModel);
+                        if (change) {
+                            changes.push(change);
+                        }
+                    }
+                }
+            }
+            // Also check for tool_result entries that might contain file info
+            if (entry.type === 'tool_result' && entry.content) {
+                // Tool results might indicate successful file operations
+                // but we primarily track from tool_use
+            }
+        }
+        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,
+        };
+    }
+    /**
+     * Parse a tool_use block to extract file changes
+     */
+    parseToolUse(block, projectPath, timestamp, model) {
+        const toolName = block.name?.toLowerCase() || '';
+        const input = block.input || {};
+        // Supported write operations - expanded list
+        const writeOps = ['write', 'write_file', 'create_file', 'str_replace_editor', 'save_file', 'create'];
+        const editOps = ['edit', 'edit_file', 'str_replace', 'apply_diff', 'patch', 'update_file'];
+        // Try various field names for file path
+        let filePath = input.path || input.file_path || input.filename || input.file || input.target || '';
+        let newContent = input.content || input.new_str || input.new_string || input.text || input.code || '';
+        let oldContent = input.old_str || input.old_string || input.old_content || input.original || '';
+        if (!filePath)
+            return null;
+        // Normalize path
+        filePath = this.normalizePath(filePath, projectPath);
+        let changeType = 'modify';
+        let linesAdded = 0;
+        let linesRemoved = 0;
+        if (writeOps.includes(toolName)) {
+            changeType = oldContent ? 'modify' : 'create';
+            linesAdded = this.countLines(newContent);
+            linesRemoved = this.countLines(oldContent);
+        }
+        else if (editOps.includes(toolName)) {
+            changeType = 'modify';
+            linesAdded = this.countLines(newContent);
+            linesRemoved = this.countLines(oldContent);
+        }
+        else {
+            // Unknown tool, try to extract what we can
+            if (newContent) {
+                linesAdded = this.countLines(newContent);
+            }
+        }
+        if (linesAdded === 0 && linesRemoved === 0)
+            return null;
+        return {
+            filePath,
+            linesAdded,
+            linesRemoved,
+            changeType,
+            timestamp: timestamp ? new Date(timestamp) : new Date(),
+            tool: this.tool,
+            content: newContent,
+            model,
+        };
+    }
+}

package/dist/scanners/codex.d.ts

@@ -0,0 +1,54 @@
+import { AISession, AITool } from '../types.js';
+import { BaseScanner } from './base.js';
+/**
+ * Scanner for OpenAI Codex CLI sessions
+ *
+ * Codex CLI stores session data in:
+ * ~/.codex/sessions/YYYY/MM/DD/*.jsonl
+ *
+ * Each JSONL entry has a top-level `type` and `payload` field:
+ * - type: "session_meta" | "turn_context" | "response_item" | "event_msg"
+ * - turn_context entries contain { payload: { cwd, model, ... } }
+ * - response_item entries with payload.type "custom_tool_call" contain
+ *   apply_patch operations with a custom patch format
+ * - response_item entries with payload.type "function_call" contain
+ *   shell_command calls
+ */
+export declare class CodexScanner extends BaseScanner {
+    get tool(): AITool;
+    get storagePath(): string;
+    scan(projectPath: string): AISession[];
+    parseSessionFile(filePath: string, projectPath: string): AISession | null;
+    /**
+     * Check if the session path belongs to the target project.
+     * The session cwd must be exactly the project path or a subdirectory of it.
+     */
+    private pathsMatch;
+    /**
+     * Parse Codex apply_patch custom_tool_call entries.
+     *
+     * The patch format looks like:
+     *   *** Begin Patch
+     *   *** Update File: path/to/file.swift
+     *   @@
+     *    context line
+     *   +added line
+     *   -removed line
+     *   *** Add File: path/to/new_file.swift
+     *   +new file content
+     *   *** End Patch
+     */
+    private parseApplyPatch;
+    /**
+     * Parse a function_call payload (e.g. shell_command with file write operations)
+     */
+    private parseFunctionCall;
+    /**
+     * Parse a legacy tool_call object to extract file changes
+     */
+    private parseToolCall;
+    /**
+     * Parse a unified diff to count added/removed lines
+     */
+    private parseDiff;
+}

package/dist/scanners/codex.js

@@ -0,0 +1,311 @@
+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 OpenAI Codex CLI sessions
+ *
+ * Codex CLI stores session data in:
+ * ~/.codex/sessions/YYYY/MM/DD/*.jsonl
+ *
+ * Each JSONL entry has a top-level `type` and `payload` field:
+ * - type: "session_meta" | "turn_context" | "response_item" | "event_msg"
+ * - turn_context entries contain { payload: { cwd, model, ... } }
+ * - response_item entries with payload.type "custom_tool_call" contain
+ *   apply_patch operations with a custom patch format
+ * - response_item entries with payload.type "function_call" contain
+ *   shell_command calls
+ */
+export class CodexScanner extends BaseScanner {
+    get tool() {
+        return AITool.CODEX;
+    }
+    get storagePath() {
+        return '~/.codex/sessions';
+    }
+    scan(projectPath) {
+        const sessions = [];
+        const basePath = this.resolveStoragePath();
+        if (!fs.existsSync(basePath)) {
+            return sessions;
+        }
+        try {
+            // Recursively find all JSONL files
+            const files = glob.sync('**/*.jsonl', { cwd: basePath });
+            for (const file of files) {
+                const fullPath = path.join(basePath, file);
+                const session = this.parseSessionFile(fullPath, projectPath);
+                if (session && session.changes.length > 0) {
+                    sessions.push(session);
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return sessions;
+    }
+    parseSessionFile(filePath, projectPath) {
+        const entries = this.readJsonlFile(filePath);
+        if (entries.length === 0)
+            return null;
+        const changes = [];
+        let sessionTimestamp = null;
+        let sessionProjectPath = null;
+        for (const entry of entries) {
+            const payload = entry.payload || {};
+            // Extract timestamp
+            if (!sessionTimestamp && entry.timestamp) {
+                sessionTimestamp = new Date(entry.timestamp);
+            }
+            // Extract project path from turn_context or session_meta
+            if (!sessionProjectPath) {
+                if (entry.type === 'turn_context' && payload.cwd) {
+                    sessionProjectPath = payload.cwd;
+                }
+                else if (entry.type === 'session_meta' && payload.cwd) {
+                    sessionProjectPath = payload.cwd;
+                }
+            }
+            // 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);
+                changes.push(...patchChanges);
+                continue;
+            }
+            // Handle function_call (shell_command with file writes)
+            if (entry.type === 'response_item' && payload.type === 'function_call') {
+                const funcName = (payload.name || '').toLowerCase();
+                let args = {};
+                try {
+                    args = typeof payload.arguments === 'string'
+                        ? JSON.parse(payload.arguments)
+                        : payload.arguments || {};
+                }
+                catch {
+                    continue;
+                }
+                const change = this.parseFunctionCall(funcName, args, projectPath, entry.timestamp);
+                if (change) {
+                    changes.push(change);
+                }
+                continue;
+            }
+            // Legacy format: top-level tool_calls / function_calls arrays
+            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);
+                    if (change) {
+                        changes.push(change);
+                    }
+                }
+            }
+            // Legacy: direct function format
+            if (entry.function && entry.function.name) {
+                const change = this.parseToolCall({ function: entry.function }, projectPath, entry.timestamp);
+                if (change) {
+                    changes.push(change);
+                }
+            }
+        }
+        // Filter: only include sessions that match the project path
+        if (sessionProjectPath) {
+            const normalizedSessionPath = path.resolve(sessionProjectPath);
+            const normalizedProjectPath = path.resolve(projectPath);
+            if (!this.pathsMatch(normalizedSessionPath, normalizedProjectPath)) {
+                return null;
+            }
+        }
+        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),
+        };
+    }
+    /**
+     * Check if the session path belongs to the target project.
+     * The session cwd must be exactly the project path or a subdirectory of it.
+     */
+    pathsMatch(sessionPath, projectPath) {
+        if (sessionPath === projectPath)
+            return true;
+        // Session opened inside a subdirectory of the project
+        if (sessionPath.startsWith(projectPath + '/'))
+            return true;
+        return false;
+    }
+    /**
+     * Parse Codex apply_patch custom_tool_call entries.
+     *
+     * The patch format looks like:
+     *   *** Begin Patch
+     *   *** Update File: path/to/file.swift
+     *   @@
+     *    context line
+     *   +added line
+     *   -removed line
+     *   *** Add File: path/to/new_file.swift
+     *   +new file content
+     *   *** End Patch
+     */
+    parseApplyPatch(payload, projectPath, timestamp) {
+        const name = (payload.name || '').toLowerCase();
+        if (name !== 'apply_patch')
+            return [];
+        const input = payload.input || '';
+        if (!input)
+            return [];
+        const changes = [];
+        const lines = input.split('\n');
+        let currentFile = null;
+        let changeType = 'modify';
+        let linesAdded = 0;
+        let linesRemoved = 0;
+        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: '',
+                });
+            }
+            currentFile = null;
+            linesAdded = 0;
+            linesRemoved = 0;
+            changeType = 'modify';
+        };
+        for (const line of lines) {
+            if (line.startsWith('*** Update File:')) {
+                flushFile();
+                currentFile = line.replace('*** Update File:', '').trim();
+                changeType = 'modify';
+            }
+            else if (line.startsWith('*** Add File:')) {
+                flushFile();
+                currentFile = line.replace('*** Add File:', '').trim();
+                changeType = 'create';
+            }
+            else if (line.startsWith('*** Delete File:')) {
+                flushFile();
+                currentFile = line.replace('*** Delete File:', '').trim();
+                changeType = 'delete';
+            }
+            else if (line.startsWith('*** ')) {
+                // Other directives (Begin Patch, End Patch, etc.) — skip
+                continue;
+            }
+            else if (line.startsWith('@@')) {
+                // Hunk header — skip
+                continue;
+            }
+            else if (currentFile) {
+                if (line.startsWith('+')) {
+                    linesAdded++;
+                }
+                else if (line.startsWith('-')) {
+                    linesRemoved++;
+                }
+                // Context lines (starting with ' ') are ignored
+            }
+        }
+        flushFile();
+        return changes;
+    }
+    /**
+     * Parse a function_call payload (e.g. shell_command with file write operations)
+     */
+    parseFunctionCall(funcName, args, projectPath, 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 || '';
+        let newContent = args.content || args.new_content || args.text || args.code || args.data || '';
+        let oldContent = args.old_content || args.original || args.old_text || '';
+        if (!filePath)
+            return null;
+        filePath = this.normalizePath(filePath, projectPath);
+        let changeType = 'modify';
+        let linesAdded = 0;
+        let linesRemoved = 0;
+        if (writeOps.includes(funcName)) {
+            changeType = 'create';
+            linesAdded = this.countLines(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;
+                linesRemoved = diffStats.removed;
+            }
+        }
+        else {
+            return null;
+        }
+        if (linesAdded === 0 && linesRemoved === 0)
+            return null;
+        return {
+            filePath,
+            linesAdded,
+            linesRemoved,
+            changeType,
+            timestamp: timestamp ? new Date(timestamp) : new Date(),
+            tool: this.tool,
+            content: newContent,
+        };
+    }
+    /**
+     * Parse a legacy tool_call object to extract file changes
+     */
+    parseToolCall(toolCall, projectPath, timestamp) {
+        const func = toolCall.function;
+        if (!func)
+            return null;
+        const funcName = (func.name || '').toLowerCase();
+        let args = {};
+        try {
+            if (typeof func.arguments === 'string') {
+                args = JSON.parse(func.arguments);
+            }
+            else if (typeof func.arguments === 'object') {
+                args = func.arguments || {};
+            }
+        }
+        catch {
+            return null;
+        }
+        return this.parseFunctionCall(funcName, args, projectPath, timestamp);
+    }
+    /**
+     * Parse a unified diff to count added/removed lines
+     */
+    parseDiff(diff) {
+        let added = 0;
+        let removed = 0;
+        const lines = diff.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('+') && !line.startsWith('+++')) {
+                added++;
+            }
+            else if (line.startsWith('-') && !line.startsWith('---')) {
+                removed++;
+            }
+        }
+        return { added, removed };
+    }
+}