ai-credit 1.0.0

package/dist/reporter.js

@@ -0,0 +1,372 @@
+import * as fs from 'fs';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { AITool } from './types.js';
+/**
+ * Tool display names
+ */
+const TOOL_NAMES = {
+    [AITool.CLAUDE_CODE]: 'Claude Code',
+    [AITool.CODEX]: 'Codex CLI',
+    [AITool.GEMINI]: 'Gemini CLI',
+    [AITool.AIDER]: 'Aider',
+    [AITool.OPENCODE]: 'Opencode',
+};
+/**
+ * Tool colors for console output
+ */
+const TOOL_COLORS = {
+    [AITool.CLAUDE_CODE]: chalk.hex('#D97757'),
+    [AITool.CODEX]: chalk.hex('#00A67E'),
+    [AITool.GEMINI]: chalk.hex('#4796E3'),
+    [AITool.AIDER]: chalk.hex('#D93B3B'),
+    [AITool.OPENCODE]: chalk.yellow,
+};
+/**
+ * Console reporter for terminal output
+ */
+export class ConsoleReporter {
+    /**
+     * Print the full summary report
+     */
+    printSummary(stats) {
+        this.printHeader(stats);
+        this.printOverview(stats);
+        this.printToolBreakdown(stats);
+        this.printDistributionBar(stats);
+    }
+    /**
+     * Print report header
+     */
+    printHeader(stats) {
+        const boxWidth = 50;
+        const title = 'AI Contribution Analysis';
+        const repoLine = `Repository: ${stats.repoPath}`;
+        const timeLine = `Scan time: ${stats.scanTime.toLocaleString()}`;
+        console.log();
+        console.log(chalk.cyan('╭' + '─'.repeat(boxWidth) + '╮'));
+        console.log(chalk.cyan('│') + ' ' + chalk.bold(title.padEnd(boxWidth - 1)) + chalk.cyan('│'));
+        console.log(chalk.cyan('│') + ' ' + repoLine.substring(0, boxWidth - 1).padEnd(boxWidth - 1) + chalk.cyan('│'));
+        console.log(chalk.cyan('│') + ' ' + timeLine.padEnd(boxWidth - 1) + chalk.cyan('│'));
+        console.log(chalk.cyan('╰' + '─'.repeat(boxWidth) + '╯'));
+        console.log();
+    }
+    /**
+     * Print overview statistics
+     */
+    printOverview(stats) {
+        console.log(chalk.bold('                    📊 Overview'));
+        const table = new Table({
+            head: ['Metric', 'Value', 'AI Contribution'].map(h => chalk.bold(h)),
+            style: { head: [], border: [] },
+        });
+        const fileRatio = stats.totalFiles > 0
+            ? ((stats.aiTouchedFiles / stats.totalFiles) * 100).toFixed(1)
+            : '0.0';
+        const lineRatio = stats.totalLines > 0
+            ? ((stats.aiContributedLines / stats.totalLines) * 100).toFixed(1)
+            : '0.0';
+        table.push(['Total Files', stats.totalFiles.toString(), `${stats.aiTouchedFiles} (${fileRatio}%)`], ['Total Lines', stats.totalLines.toString(), `${stats.aiContributedLines} (${lineRatio}%)`], ['AI Sessions', stats.sessions.length.toString(), '-']);
+        console.log(table.toString());
+        console.log();
+    }
+    /**
+     * Print breakdown by AI tool
+     */
+    printToolBreakdown(stats) {
+        if (stats.byTool.size === 0) {
+            console.log(chalk.yellow('No AI contributions found.'));
+            return;
+        }
+        console.log(chalk.bold('                🤖 Contribution by AI Tool'));
+        const table = new Table({
+            head: ['Tool / Model', 'Sessions', 'Files', 'Lines Added', 'Lines Removed', 'Share'].map(h => chalk.bold(h)),
+            style: { head: [], border: [] },
+        });
+        const totalLines = Array.from(stats.byTool.values())
+            .reduce((sum, t) => sum + t.linesAdded, 0);
+        for (const [tool, toolStats] of stats.byTool) {
+            const share = totalLines > 0
+                ? ((toolStats.linesAdded / totalLines) * 100).toFixed(1)
+                : '0.0';
+            const color = TOOL_COLORS[tool] || chalk.white;
+            // Add tool row
+            table.push([
+                color(TOOL_NAMES[tool]),
+                toolStats.sessionsCount.toString(),
+                toolStats.totalFiles.toString(),
+                chalk.green(`+${toolStats.linesAdded}`),
+                chalk.red(`-${toolStats.linesRemoved}`),
+                `${share}%`,
+            ]);
+            // Add model rows (if known and more than just "unknown" or if explicitly wanted)
+            if (toolStats.byModel.size > 0) {
+                // Sort models by lines added
+                const sortedModels = Array.from(toolStats.byModel.entries())
+                    .sort((a, b) => b[1].linesAdded - a[1].linesAdded);
+                for (const [modelName, modelStats] of sortedModels) {
+                    // Skip if model is 'unknown' and it's the only one (redundant)
+                    if (modelName === 'unknown' && toolStats.byModel.size === 1)
+                        continue;
+                    const modelShare = toolStats.linesAdded > 0
+                        ? ((modelStats.linesAdded / toolStats.linesAdded) * 100).toFixed(1)
+                        : '0.0';
+                    table.push([
+                        chalk.dim(`  └─ ${modelName}`),
+                        chalk.dim(modelStats.sessionsCount.toString()),
+                        chalk.dim(modelStats.totalFiles.toString()),
+                        chalk.dim(`+${modelStats.linesAdded}`),
+                        chalk.dim(`-${modelStats.linesRemoved}`),
+                        chalk.dim(`${modelShare}% (of tool)`),
+                    ]);
+                }
+            }
+        }
+        console.log(table.toString());
+        console.log();
+    }
+    /**
+     * Print distribution pie chart showing all code proportions
+     */
+    printDistributionBar(stats) {
+        if (stats.totalLines === 0)
+            return;
+        console.log(chalk.bold('📈 Contribution Distribution'));
+        console.log();
+        // Build slices: proportion each AI tool's share of repo lines + Unknown/Human
+        // Now using Verified Lines (Verified Existence logic)
+        const slices = [];
+        for (const [tool, toolStats] of stats.byTool) {
+            if (toolStats.verifiedLines > 0) {
+                const color = TOOL_COLORS[tool] || chalk.white;
+                slices.push({ label: TOOL_NAMES[tool], value: toolStats.verifiedLines, color: (s) => color(s) });
+            }
+        }
+        const humanLines = Math.max(0, stats.totalLines - stats.aiContributedLines);
+        if (humanLines > 0) {
+            slices.push({ label: 'Unknown/Human', value: humanLines, color: (s) => chalk.gray(s) });
+        }
+        const total = slices.reduce((sum, s) => sum + s.value, 0);
+        // Note: total should be approx stats.totalLines (or equal if we assume aiContributedLines is sum of verifiedLines)
+        if (total === 0)
+            return;
+        // Render stacked horizontal bar
+        const barWidth = 60;
+        let bar = '';
+        const segments = [];
+        for (const slice of slices) {
+            const width = Math.max(1, Math.round((slice.value / total) * barWidth));
+            segments.push({ width, color: slice.color });
+        }
+        // Adjust rounding so total width matches barWidth
+        const totalWidth = segments.reduce((s, seg) => s + seg.width, 0);
+        if (totalWidth !== barWidth && segments.length > 0) {
+            // Just subtract/add from the largest or last segment to make it fit
+            segments[segments.length - 1].width += barWidth - totalWidth;
+        }
+        for (const seg of segments) {
+            // Ensure width is not negative if adjustment failed heavily
+            if (seg.width > 0) {
+                bar += seg.color('█'.repeat(seg.width));
+            }
+        }
+        console.log(`  ${bar}`);
+        console.log();
+        // Legend with percentage bars per slice
+        for (const slice of slices) {
+            const pct = (slice.value / total) * 100;
+            const dot = slice.color('●');
+            console.log(`  ${dot} ${slice.label.padEnd(14)} ${pct.toFixed(1).padStart(5)}%  (${slice.value} lines)`);
+        }
+        console.log();
+    }
+    /**
+     * Print file-level statistics
+     */
+    printFiles(stats, limit = 20) {
+        console.log(chalk.bold('                📁 Top AI-Contributed Files'));
+        const table = new Table({
+            head: ['File', 'Total Lines', 'AI Lines', 'AI Ratio', 'Contributors'].map(h => chalk.bold(h)),
+            style: { head: [], border: [] },
+            colWidths: [30, 12, 10, 10, 15],
+        });
+        // Sort files by AI contribution ratio
+        const sortedFiles = Array.from(stats.byFile.entries())
+            .filter(([, s]) => s.aiContributedLines > 0)
+            .sort((a, b) => b[1].aiContributionRatio - a[1].aiContributionRatio)
+            .slice(0, limit);
+        for (const [filePath, fileStats] of sortedFiles) {
+            const ratio = (fileStats.aiContributionRatio * 100).toFixed(1) + '%';
+            const contributors = Array.from(fileStats.contributions.keys())
+                .map(t => TOOL_NAMES[t])
+                .join(', ');
+            // Truncate long file paths
+            const displayPath = filePath.length > 27
+                ? '...' + filePath.slice(-24)
+                : filePath;
+            table.push([
+                displayPath,
+                fileStats.totalLines.toString(),
+                fileStats.aiContributedLines.toString(),
+                ratio,
+                contributors.length > 12 ? contributors.slice(0, 12) + '...' : contributors,
+            ]);
+        }
+        console.log(table.toString());
+        console.log();
+    }
+    /**
+     * Print timeline of AI activity
+     */
+    printTimeline(stats, limit = 20) {
+        console.log(chalk.bold('                📅 Recent AI Activity'));
+        const table = new Table({
+            head: ['Date', 'Tool', 'Files', 'Changes'].map(h => chalk.bold(h)),
+            style: { head: [], border: [] },
+        });
+        const recentSessions = stats.sessions.slice(-limit).reverse();
+        for (const session of recentSessions) {
+            const date = session.timestamp.toLocaleString('en-US', {
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit',
+                hour: '2-digit',
+                minute: '2-digit',
+            });
+            const color = TOOL_COLORS[session.tool] || chalk.white;
+            table.push([
+                chalk.dim(date),
+                color(TOOL_NAMES[session.tool]),
+                session.totalFilesChanged.toString(),
+                chalk.green(`+${session.totalLinesAdded}`) + ' ' + chalk.red(`-${session.totalLinesRemoved}`),
+            ]);
+        }
+        console.log(table.toString());
+        console.log();
+    }
+}
+/**
+ * JSON reporter for structured output
+ */
+export class JsonReporter {
+    /**
+     * Generate JSON report
+     */
+    generate(stats) {
+        const output = {
+            repo_path: stats.repoPath,
+            scan_time: stats.scanTime.toISOString(),
+            overview: {
+                total_files: stats.totalFiles,
+                total_lines: stats.totalLines,
+                ai_touched_files: stats.aiTouchedFiles,
+                ai_contributed_lines: stats.aiContributedLines,
+                ai_file_ratio: stats.totalFiles > 0 ? stats.aiTouchedFiles / stats.totalFiles : 0,
+                ai_line_ratio: stats.totalLines > 0 ? stats.aiContributedLines / stats.totalLines : 0,
+                total_sessions: stats.sessions.length,
+            },
+            by_tool: Object.fromEntries(Array.from(stats.byTool.entries()).map(([tool, toolStats]) => [
+                tool,
+                {
+                    sessions_count: toolStats.sessionsCount,
+                    files_created: toolStats.filesCreated,
+                    files_modified: toolStats.filesModified,
+                    total_files: toolStats.totalFiles,
+                    lines_added: toolStats.linesAdded,
+                    lines_removed: toolStats.linesRemoved,
+                    net_lines: toolStats.netLines,
+                },
+            ])),
+            by_file: Object.fromEntries(Array.from(stats.byFile.entries())
+                .filter(([, s]) => s.aiContributedLines > 0)
+                .map(([filePath, fileStats]) => [
+                filePath,
+                {
+                    total_lines: fileStats.totalLines,
+                    ai_contributed_lines: fileStats.aiContributedLines,
+                    ai_contribution_ratio: fileStats.aiContributionRatio,
+                    contributions: Object.fromEntries(fileStats.contributions),
+                },
+            ])),
+        };
+        return JSON.stringify(output, null, 2);
+    }
+    /**
+     * Save JSON report to file
+     */
+    save(stats, outputPath) {
+        const json = this.generate(stats);
+        fs.writeFileSync(outputPath, json, 'utf-8');
+    }
+}
+/**
+ * Markdown reporter for documentation
+ */
+export class MarkdownReporter {
+    /**
+     * Generate Markdown report
+     */
+    generate(stats) {
+        const lines = [];
+        lines.push('# AI Contribution Report');
+        lines.push('');
+        lines.push(`**Repository:** \`${stats.repoPath}\``);
+        lines.push(`**Generated:** ${stats.scanTime.toLocaleString()}`);
+        lines.push('');
+        // Overview
+        lines.push('## Overview');
+        lines.push('');
+        lines.push('| Metric | Total | AI Contribution |');
+        lines.push('|--------|-------|-----------------|');
+        const fileRatio = stats.totalFiles > 0
+            ? ((stats.aiTouchedFiles / stats.totalFiles) * 100).toFixed(1)
+            : '0.0';
+        const lineRatio = stats.totalLines > 0
+            ? ((stats.aiContributedLines / stats.totalLines) * 100).toFixed(1)
+            : '0.0';
+        lines.push(`| Files | ${stats.totalFiles} | ${stats.aiTouchedFiles} (${fileRatio}%) |`);
+        lines.push(`| Lines | ${stats.totalLines} | ${stats.aiContributedLines} (${lineRatio}%) |`);
+        lines.push(`| Sessions | ${stats.sessions.length} | - |`);
+        lines.push('');
+        // By Tool
+        if (stats.byTool.size > 0) {
+            lines.push('## Contribution by AI Tool');
+            lines.push('');
+            lines.push('| Tool | Sessions | Files | Lines Added | Lines Removed | Share |');
+            lines.push('|------|----------|-------|-------------|---------------|-------|');
+            const totalLines = Array.from(stats.byTool.values())
+                .reduce((sum, t) => sum + t.linesAdded, 0);
+            for (const [tool, toolStats] of stats.byTool) {
+                const share = totalLines > 0
+                    ? ((toolStats.linesAdded / totalLines) * 100).toFixed(1)
+                    : '0.0';
+                lines.push(`| ${TOOL_NAMES[tool]} | ${toolStats.sessionsCount} | ${toolStats.totalFiles} | +${toolStats.linesAdded} | -${toolStats.linesRemoved} | ${share}% |`);
+            }
+            lines.push('');
+        }
+        // Top Files
+        const topFiles = Array.from(stats.byFile.entries())
+            .filter(([, s]) => s.aiContributedLines > 0)
+            .sort((a, b) => b[1].aiContributionRatio - a[1].aiContributionRatio)
+            .slice(0, 10);
+        if (topFiles.length > 0) {
+            lines.push('## Top AI-Contributed Files');
+            lines.push('');
+            lines.push('| File | Total Lines | AI Lines | AI Ratio |');
+            lines.push('|------|-------------|----------|----------|');
+            for (const [filePath, fileStats] of topFiles) {
+                const ratio = (fileStats.aiContributionRatio * 100).toFixed(1) + '%';
+                lines.push(`| \`${filePath}\` | ${fileStats.totalLines} | ${fileStats.aiContributedLines} | ${ratio} |`);
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Save Markdown report to file
+     */
+    save(stats, outputPath) {
+        const markdown = this.generate(stats);
+        fs.writeFileSync(outputPath, markdown, 'utf-8');
+    }
+}

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,194 @@
+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,
+                });
+            }
+        }
+        // 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,
+                    });
+                }
+            }
+        }
+        // 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,
+                });
+            }
+        }
+        // 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;
+            }
+        }
+        return Array.from(byFile.values()).filter(c => c.filePath !== 'unknown');
+    }
+}

package/dist/scanners/base.d.ts

@@ -0,0 +1,56 @@
+import { AISession, AITool } from '../types.js';
+/**
+ * Base class for AI tool scanners
+ */
+export declare abstract class BaseScanner {
+    protected homeDir: string;
+    constructor();
+    /**
+     * The AI tool this scanner handles
+     */
+    abstract get tool(): AITool;
+    /**
+     * The storage path for this tool's session data
+     */
+    abstract get storagePath(): string;
+    /**
+     * Check if this tool has data available
+     */
+    isAvailable(): boolean;
+    /**
+     * Resolve the full storage path
+     */
+    protected resolveStoragePath(): string;
+    /**
+     * Scan for sessions related to a specific project
+     */
+    abstract scan(projectPath: string): AISession[];
+    /**
+     * Parse a session file and extract file changes
+     */
+    abstract parseSessionFile(filePath: string, projectPath: string): AISession | null;
+    /**
+     * Count lines in a string
+     */
+    protected countLines(content: string | undefined): number;
+    /**
+     * Normalize file path relative to project
+     */
+    protected normalizePath(filePath: string, projectPath: string): string;
+    /**
+     * Check if a file path belongs to the project
+     */
+    protected isProjectFile(filePath: string, projectPath: string): boolean;
+    /**
+     * Read and parse JSON file safely
+     */
+    protected readJsonFile(filePath: string): any;
+    /**
+     * Read and parse JSONL file safely
+     */
+    protected readJsonlFile(filePath: string): any[];
+    /**
+     * Generate a unique session ID
+     */
+    protected generateSessionId(filePath: string): string;
+}