git-trace 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,858 @@
+#!/usr/bin/env node
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { rmSync, existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// Default AI detection patterns — browser-safe, no Node.js dependencies
+const DEFAULT_PATTERNS = {
+    emails: [
+        'noreply@cursor.sh',
+        'claude@anthropic.com',
+        'bot@github.com',
+        'copilot',
+        'cursor'
+    ],
+    messages: [
+        'Co-Authored-By: Claude',
+        'Co-Authored-By: Cursor',
+        'Generated-by:',
+        '[skip-human-review]',
+        'AI-generated'
+    ]
+};
+
+// Shared utilities for git adapters — parse diffs, detect AI authors, format dates
+// Parse unified diff format into lines
+function parseDiff(diffText) {
+    const lines = [];
+    for (const line of diffText.split('\n')){
+        // Skip diff headers
+        if (line.startsWith('@@')) continue;
+        if (line.startsWith('+++') || line.startsWith('---')) continue;
+        if (line.startsWith('index') || line.startsWith('diff')) continue;
+        if (line.startsWith('new file') || line.startsWith('deleted file')) continue;
+        if (line.startsWith('+')) {
+            lines.push({
+                type: 'add',
+                content: line.slice(1)
+            });
+        } else if (line.startsWith('-')) {
+            lines.push({
+                type: 'remove',
+                content: line.slice(1)
+            });
+        } else {
+            lines.push({
+                type: 'ctx',
+                content: line.slice(1) || ''
+            });
+        }
+    }
+    return lines;
+}
+// Compile string arrays to lowercase Sets for fast O(1) lookup
+function compilePatterns(patterns) {
+    return {
+        emails: new Set(patterns.emails.map((p)=>p.toLowerCase())),
+        messages: new Set(patterns.messages.map((p)=>p.toLowerCase()))
+    };
+}
+// Cached compiled defaults
+const CACHED_DEFAULTS = compilePatterns(DEFAULT_PATTERNS);
+// Detect if author is AI based on patterns
+function detectAI(login, email, message, patterns) {
+    const compiled = patterns ? compilePatterns(patterns) : CACHED_DEFAULTS;
+    const toCheck = [
+        login,
+        email,
+        message
+    ].filter(Boolean);
+    for (const str of toCheck){
+        const lower = str.toLowerCase();
+        for (const pattern of compiled.emails){
+            if (lower === pattern || lower.includes(pattern)) return 'ai';
+        }
+        for (const pattern of compiled.messages){
+            if (lower.includes(pattern)) return 'ai';
+        }
+    }
+    return 'human';
+}
+// Format date to relative time string
+function formatRelativeTime(dateStr) {
+    const date = new Date(dateStr);
+    const diff = Date.now() - date.getTime();
+    const days = Math.floor(diff / 86400000);
+    if (days > 30) {
+        return date.toLocaleDateString('en-US', {
+            month: 'short',
+            day: 'numeric'
+        });
+    }
+    if (days > 0) return `${days}d ago`;
+    const hours = Math.floor(diff / 3600000);
+    if (hours > 0) return `${hours}h ago`;
+    const minutes = Math.floor(diff / 60000);
+    if (minutes > 0) return `${minutes}m ago`;
+    return 'just now';
+}
+// Extract short hash from full SHA (7 characters)
+function shortHash(sha) {
+    return sha.slice(0, 7);
+}
+// Get first line of commit message
+function firstLine(message) {
+    return message.split('\n')[0];
+}
+
+function asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$4(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+const execAsync = promisify(exec);
+/**
+ * Validate file path to prevent command injection
+ * Rejects paths with shell metacharacters or absolute paths
+ */ function validatePath(filePath) {
+    // Reject shell metacharacters that could escape git quotes
+    const dangerous = /[\n\r`$\\;&|<>]/;
+    if (dangerous.test(filePath)) {
+        throw new Error(`Invalid file path: contains potentially dangerous characters`);
+    }
+    // Reject absolute paths (should work relative to cwd)
+    if (filePath.startsWith('/') || /^[A-Za-z]:/.test(filePath)) {
+        throw new Error(`Invalid file path: use relative paths only`);
+    }
+}
+function parseGitLog(filePath, last = 10) {
+    return _async_to_generator$4(function*() {
+        validatePath(filePath);
+        const format = '%H|%an|%ae|%s|%cr';
+        try {
+            const { stdout } = yield execAsync(`git log -${last} --follow -p "--format=${format}" -- "${filePath}"`, {
+                cwd: process.cwd(),
+                shell: true,
+                windowsHide: true
+            });
+            return parseGitLogOutput(stdout);
+        } catch (error) {
+            throw new Error(`Failed to parse git log: ${error.message}`);
+        }
+    })();
+}
+function parseGitLogOutput(output) {
+    const commits = [];
+    const lines = output.split('\n');
+    let currentCommit = null;
+    let inDiff = false;
+    for (const line of lines){
+        if (/^[a-f0-9]{40}\|/.test(line)) {
+            if (currentCommit == null ? void 0 : currentCommit.lines) commits.push(currentCommit);
+            const [hash, author, email, message, time] = line.split('|');
+            currentCommit = {
+                hash: hash.slice(0, 7),
+                author,
+                message,
+                authorType: detectAI(undefined, email, message),
+                time,
+                lines: []
+            };
+            inDiff = false;
+            continue;
+        }
+        if (line.startsWith('diff --git')) {
+            inDiff = true;
+            continue;
+        }
+        if (inDiff && currentCommit) {
+            if (line.startsWith('@@') || line.startsWith('index') || line.startsWith('---') || line.startsWith('+++')) {
+                continue;
+            }
+            currentCommit.lines.push(...parseDiff(line));
+        }
+    }
+    if (currentCommit == null ? void 0 : currentCommit.lines) commits.push(currentCommit);
+    return commits;
+}
+
+// Local cache for GitHub API responses to avoid rate limits
+const CACHE_DIR = join(homedir(), '.trace-cache');
+const CACHE_TTL = 24 * 60 * 60 * 1000 // 24 hours
+;
+function sanitizePath(path) {
+    // Remove ../, ./, and replace slashes with dashes
+    return path.replace(/\.\.\//g, '').replace(/\.\//g, '').replace(/[\/\\]/g, '-').replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+function getCacheKey(repo, file, last) {
+    const key = `${sanitizePath(repo)}-${sanitizePath(file)}-${last}.json`;
+    return join(CACHE_DIR, key);
+}
+function getCached(repo, file, last) {
+    const cachePath = getCacheKey(repo, file, last);
+    if (!existsSync(cachePath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(cachePath, 'utf-8');
+        const entry = JSON.parse(content);
+        // Check if cache is expired
+        const now = Date.now();
+        if (now - entry.timestamp > CACHE_TTL) {
+            return null;
+        }
+        return entry.data;
+    } catch (unused) {
+        return null;
+    }
+}
+function setCached(repo, file, last, data) {
+    const cachePath = getCacheKey(repo, file, last);
+    try {
+        // Ensure cache directory exists
+        if (!existsSync(CACHE_DIR)) {
+            mkdirSync(CACHE_DIR, {
+                recursive: true
+            });
+        }
+        const entry = {
+            data,
+            timestamp: Date.now(),
+            repo,
+            file,
+            last
+        };
+        writeFileSync(cachePath, JSON.stringify(entry, null, 2));
+    } catch (unused) {
+    // Silently fail - caching is optional
+    }
+}
+function clearCache() {
+    try {
+        rmSync(CACHE_DIR, {
+            recursive: true,
+            force: true
+        });
+    } catch (unused) {
+    // Ignore
+    }
+}
+function getCacheInfo() {
+    try {
+        if (!existsSync(CACHE_DIR)) return [];
+        const files = readdirSync(CACHE_DIR);
+        const entries = [];
+        for (const file of files){
+            try {
+                const content = readFileSync(join(CACHE_DIR, file), 'utf-8');
+                const entry = JSON.parse(content);
+                entries.push(entry);
+            } catch (unused) {
+            // Skip invalid files
+            }
+        }
+        return entries;
+    } catch (unused) {
+        return [];
+    }
+}
+
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+const DEFAULT = {
+    aiPatterns: DEFAULT_PATTERNS,
+    last: 10
+};
+let cached = null;
+function loadConfig(cwd) {
+    if (cached) return cached;
+    const paths = [
+        join(homedir(), '.tracerc')
+    ];
+    for (const path of paths){
+        if (existsSync(path)) {
+            try {
+                const user = JSON.parse(readFileSync(path, 'utf-8'));
+                const merged = _extends({}, DEFAULT, user);
+                cached = merged;
+                return cached;
+            } catch (unused) {
+            // Invalid config, use defaults
+            }
+        }
+    }
+    cached = DEFAULT;
+    return cached;
+}
+function getAIPatterns(config) {
+    const patterns = (config || loadConfig()).aiPatterns;
+    return {
+        emails: (patterns == null ? void 0 : patterns.emails) || DEFAULT.aiPatterns.emails,
+        messages: (patterns == null ? void 0 : patterns.messages) || DEFAULT.aiPatterns.messages
+    };
+}
+
+// GitHub API adapter — fetches commits with diffs from repositories
+function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$3(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+const GITHUB_API = 'https://api.github.com';
+function fetchCommits$3(owner, repo, file, last = 10, token, useCache = true, onCacheHit, onCacheWrite) {
+    return _async_to_generator$3(function*() {
+        const repoKey = `${owner}/${repo}`;
+        const config = loadConfig();
+        // Check cache
+        if (useCache) {
+            const cached = getCached(repoKey, file, last);
+            if (cached) {
+                return cached;
+            }
+        }
+        const headers = {
+            'Accept': 'application/vnd.github.v3+json'
+        };
+        if (token) headers['Authorization'] = `Bearer ${token}`;
+        // Fetch commits list
+        const listUrl = `${GITHUB_API}/repos/${owner}/${repo}/commits?path=${encodeURIComponent(file)}&per_page=${last}`;
+        const listRes = yield fetch(listUrl, {
+            headers
+        });
+        if (!listRes.ok) {
+            if (listRes.status === 403) {
+                const reset = listRes.headers.get('X-RateLimit-Reset');
+                const resetTime = reset ? new Date(parseInt(reset) * 1000).toLocaleTimeString() : 'unknown';
+                throw new Error(`Rate limit exceeded. Resets at ${resetTime}`);
+            }
+            if (listRes.status === 404) throw new Error(`Not found: ${owner}/${repo}/${file}`);
+            throw new Error(`GitHub API error: ${listRes.status}`);
+        }
+        const commitsList = yield listRes.json();
+        // Fetch diffs in parallel
+        const results = yield Promise.allSettled(commitsList.map((c)=>_async_to_generator$3(function*() {
+                const commitUrl = `${GITHUB_API}/repos/${owner}/${repo}/commits/${c.sha}`;
+                const commitRes = yield fetch(commitUrl, {
+                    headers
+                });
+                if (!commitRes.ok) return null;
+                const detail = yield commitRes.json();
+                return parseCommit$2(detail, config);
+            })()));
+        const commits = results.map((r)=>r.status === 'fulfilled' ? r.value : null).filter((c)=>c !== null);
+        // Cache results
+        if (useCache && commits.length > 0) {
+            setCached(repoKey, file, last, commits);
+        }
+        return commits;
+    })();
+}
+function parseCommit$2(data, config) {
+    var _data_author, _data_commit_author, _data_author1, _data_commit_author1;
+    const lines = [];
+    const aiPatterns = getAIPatterns(config);
+    for (const file of data.files || []){
+        if (!file.patch) continue;
+        lines.push(...parseDiff(file.patch));
+    }
+    return {
+        hash: shortHash(data.sha),
+        message: firstLine(data.commit.message),
+        author: ((_data_author = data.author) == null ? void 0 : _data_author.login) || ((_data_commit_author = data.commit.author) == null ? void 0 : _data_commit_author.name) || 'Unknown',
+        authorType: detectAI((_data_author1 = data.author) == null ? void 0 : _data_author1.login, (_data_commit_author1 = data.commit.author) == null ? void 0 : _data_commit_author1.email, data.commit.message, aiPatterns),
+        time: formatRelativeTime(data.commit.author.date),
+        lines
+    };
+}
+
+// GitLab API adapter — fetches commits with diffs from repositories
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+const GITLAB_API = 'https://gitlab.com/api/v4';
+function fetchCommits$2(owner, repo, file, last = 10, token, baseUrl) {
+    return _async_to_generator$2(function*() {
+        const api = GITLAB_API;
+        const projectId = encodeURIComponent(`${owner}/${repo}`);
+        const headers = {};
+        if (token) headers['PRIVATE-TOKEN'] = token;
+        // Fetch commits list
+        const listUrl = `${api}/projects/${projectId}/repository/commits?path=${encodeURIComponent(file)}&per_page=${last}`;
+        const listRes = yield fetch(listUrl, {
+            headers
+        });
+        if (!listRes.ok) {
+            if (listRes.status === 401) throw new Error('GitLab authentication failed');
+            if (listRes.status === 404) throw new Error(`Not found: ${owner}/${repo}/${file}`);
+            throw new Error(`GitLab API error: ${listRes.status}`);
+        }
+        const commitsList = yield listRes.json();
+        // Fetch diffs in parallel
+        const results = yield Promise.allSettled(commitsList.map((c)=>_async_to_generator$2(function*() {
+                const diffUrl = `${api}/projects/${projectId}/repository/commits/${c.id}/diff?per_page=100`;
+                const diffRes = yield fetch(diffUrl, {
+                    headers
+                });
+                if (!diffRes.ok) return null;
+                const diff = yield diffRes.json();
+                return parseCommit$1(c, diff);
+            })()));
+        return results.map((r)=>r.status === 'fulfilled' ? r.value : null).filter((c)=>c !== null);
+    })();
+}
+function parseCommit$1(data, diffData) {
+    const lines = [];
+    for (const file of diffData){
+        if (!file.diff) continue;
+        lines.push(...parseDiff(file.diff));
+    }
+    return {
+        hash: shortHash(data.id),
+        message: firstLine(data.title),
+        author: data.author_name || 'Unknown',
+        authorType: detectAI(data.author_name, data.author_email, data.title),
+        time: formatRelativeTime(data.created_at),
+        lines
+    };
+}
+
+// Gitea API adapter — fetches commits with diffs from repositories
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+const GITEA_API = 'https://gitea.com/api/v1';
+function fetchCommits$1(owner, repo, file, last = 10, token, baseUrl) {
+    return _async_to_generator$1(function*() {
+        const api = GITEA_API;
+        const headers = {
+            'Accept': 'application/json'
+        };
+        if (token) headers['Authorization'] = `token ${token}`;
+        // Fetch commits list
+        const listUrl = `${api}/repos/${owner}/${repo}/commits?path=${encodeURIComponent(file)}&limit=${last}`;
+        const listRes = yield fetch(listUrl, {
+            headers
+        });
+        if (!listRes.ok) {
+            if (listRes.status === 401) throw new Error('Gitea authentication failed');
+            if (listRes.status === 404) throw new Error(`Not found: ${owner}/${repo}/${file}`);
+            throw new Error(`Gitea API error: ${listRes.status}`);
+        }
+        const commitsList = yield listRes.json();
+        // Fetch diffs in parallel
+        const results = yield Promise.allSettled(commitsList.map((c)=>_async_to_generator$1(function*() {
+                const diffUrl = `${api}/repos/${owner}/${repo}/git/commits/${c.sha}/diff`;
+                const diffRes = yield fetch(diffUrl, {
+                    headers
+                });
+                if (!diffRes.ok) return null;
+                const diffText = yield diffRes.text();
+                return parseCommit(c, diffText);
+            })()));
+        return results.map((r)=>r.status === 'fulfilled' ? r.value : null).filter((c)=>c !== null);
+    })();
+}
+function parseCommit(data, diffText) {
+    var _data_author, _data_commit_author, _data_author1, _data_commit_author1;
+    return {
+        hash: shortHash(data.sha),
+        message: firstLine(data.commit.message),
+        author: ((_data_author = data.author) == null ? void 0 : _data_author.login) || ((_data_commit_author = data.commit.author) == null ? void 0 : _data_commit_author.name) || 'Unknown',
+        authorType: detectAI((_data_author1 = data.author) == null ? void 0 : _data_author1.login, (_data_commit_author1 = data.commit.author) == null ? void 0 : _data_commit_author1.email, data.commit.message),
+        time: formatRelativeTime(data.commit.author.date),
+        lines: parseDiff(diffText)
+    };
+}
+
+// Git host detection for CLI — auto-detects GitHub, GitLab, Gitea from repo strings
+// Detect host from repo URL or owner/repo string
+function detectHost(input) {
+    // GitHub: owner/repo
+    const githubMatch = input.match(/^([\w-]+)\/([\w.-]+)$/);
+    if (githubMatch) {
+        return {
+            host: 'github',
+            owner: githubMatch[1],
+            repo: githubMatch[2]
+        };
+    }
+    // GitLab URL: gitlab.com/owner/repo or gitlab.com/owner/repo.git
+    const gitlabMatch = input.match(/gitlab\.com\/([\w-]+)\/([\w.-]+)/);
+    if (gitlabMatch) {
+        return {
+            host: 'gitlab',
+            owner: gitlabMatch[1],
+            repo: gitlabMatch[2].replace('.git', '')
+        };
+    }
+    // Gitea URL: gitea.com/owner/repo or codeberg.org/owner/repo (runs Gitea)
+    const giteaMatch = input.match(/(?:gitea\.com|codeberg\.org|notabug\.org)\/([\w-]+)\/([\w.-]+)/);
+    if (giteaMatch) {
+        return {
+            host: 'gitea',
+            owner: giteaMatch[1],
+            repo: giteaMatch[2].replace('.git', '')
+        };
+    }
+    return null;
+}
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// Show cache info using getCacheInfo
+function showCacheInfo() {
+    const entries = getCacheInfo();
+    if (entries.length === 0) {
+        console.error('[trace] No cache found');
+        return;
+    }
+    console.error(`[trace] Cache: ${entries.length} entries`);
+    for (const e of entries){
+        const age = Math.floor((Date.now() - e.timestamp) / 1000 / 60) // minutes
+        ;
+        console.error(`  - ${e.repo}/${e.file} (${e.last} commits, ${age}m old)`);
+    }
+}
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+const GITLAB_TOKEN = process.env.GITLAB_TOKEN;
+const GITEA_TOKEN = process.env.GITEA_TOKEN;
+const DEFAULT_LAST = 10;
+const args = process.argv.slice(2);
+function showHelp() {
+    console.log(`
+trace v0.4.0 — Git history visualizer
+
+Usage:
+  trace <file>                       Local git log
+  trace <repo> <file>                Remote API (auto-detect host)
+  trace cache                        Show cache
+  trace cache clear                  Clear cache
+
+Supported hosts:
+  GitHub    owner/repo
+  GitLab    gitlab.com/owner/repo
+  Gitea     gitea.com/owner/repo, codeberg.org/owner/repo
+
+Options:
+  --last <n>     Commits to show (default: ${DEFAULT_LAST})
+  --json        Output JSON
+  --output <f>  Write to file
+
+Examples:
+  trace src/App.tsx
+  trace src/App.tsx --last 5 --json
+  trace doanbactam/trace src/Trace.tsx
+  trace gitlab.com/gitlab-org/gitlab-shell README.md
+  trace codeberg.org/forgejo/forgejo README.md
+  trace src/App.tsx --output embed.html
+
+Environment:
+  GITHUB_TOKEN  GitHub token for API
+  GITLAB_TOKEN  GitLab token for API
+  GITEA_TOKEN   Gitea token for API
+`);
+}
+function parseArgs() {
+    const options = {
+        last: String(DEFAULT_LAST),
+        json: false,
+        output: ''
+    };
+    for(let i = 0; i < args.length; i++){
+        const arg = args[i];
+        if (arg === '--help' || arg === '-h') {
+            showHelp();
+            process.exit(0);
+        }
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+                options[key] = args[i + 1];
+                i++;
+            } else {
+                options[key] = true;
+            }
+        }
+    }
+    return options;
+}
+function handleCacheCommand() {
+    return _async_to_generator(function*() {
+        const cacheArgs = args.slice(1);
+        if (cacheArgs.length === 0 || cacheArgs[0] === 'show' || cacheArgs[0] === 'info') {
+            showCacheInfo();
+            return;
+        }
+        if (cacheArgs[0] === 'clear') {
+            clearCache();
+            return;
+        }
+        console.error('Unknown cache command. Use: cache, cache clear');
+        process.exit(1);
+    })();
+}
+function main() {
+    return _async_to_generator(function*() {
+        if (args[0] === 'cache') {
+            yield handleCacheCommand();
+            return;
+        }
+        const options = parseArgs();
+        // Get positional args (excluding options and their values)
+        const positionalArgs = [];
+        for(let i = 0; i < args.length; i++){
+            const arg = args[i];
+            if (arg.startsWith('--')) {
+                i++; // skip value
+                continue;
+            }
+            positionalArgs.push(arg);
+        }
+        // Detect GitHub repo (owner/repo format - only one slash, no file extension like .ts/.js)
+        const repoArg = positionalArgs.find((a)=>{
+            const parts = a.split('/');
+            return parts.length === 2 && !parts[1].includes('.');
+        });
+        const fileArg = positionalArgs.find((a)=>a !== repoArg);
+        if (!fileArg && !repoArg) {
+            console.error('Error: Specify a file path or owner/repo');
+            showHelp();
+            process.exit(1);
+        }
+        const commits = yield fetchCommits(fileArg, repoArg, options);
+        if (options.json) {
+            const output = JSON.stringify(commits, null, 2);
+            writeOutput(options.output, output);
+        } else {
+            const html = generateHTML(commits);
+            writeOutput(options.output, html);
+        }
+    })();
+}
+function fetchCommits(fileArg, repoArg, options) {
+    return _async_to_generator(function*() {
+        const last = parseInt(options.last);
+        // Remote mode - auto-detect host
+        if (repoArg) {
+            const detected = detectHost(repoArg);
+            if (detected) {
+                const { host, owner, repo } = detected;
+                console.error(`[trace] Fetching from ${host}: ${owner}/${repo}/${fileArg}`);
+                switch(host){
+                    case 'github':
+                        return yield fetchCommits$3(owner, repo, fileArg, last, GITHUB_TOKEN);
+                    case 'gitlab':
+                        return yield fetchCommits$2(owner, repo, fileArg, last, GITLAB_TOKEN);
+                    case 'gitea':
+                        return yield fetchCommits$1(owner, repo, fileArg, last, GITEA_TOKEN);
+                }
+            }
+            // Fallback to GitHub for owner/repo format
+            const [owner, repo] = repoArg.split('/');
+            console.error(`[trace] Fetching from GitHub: ${owner}/${repo}/${fileArg}`);
+            return yield fetchCommits$3(owner, repo, fileArg, last, GITHUB_TOKEN);
+        }
+        // Local git mode
+        console.error(`[trace] Parsing local git: ${fileArg}`);
+        return yield parseGitLog(fileArg, last);
+    })();
+}
+function writeOutput(path, content) {
+    if (path) {
+        writeFileSync(path, content);
+        console.error(`[trace] Written to ${path}`);
+    } else {
+        console.log(content);
+    }
+}
+function generateHTML(commits) {
+    var _commits_;
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Trace — ${((_commits_ = commits[0]) == null ? void 0 : _commits_.message.split(' ')[0]) || 'Git History'}</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: 'JetBrains Mono', ui-monospace, monospace; background: #07090f; color: #e2e8f0; padding: 40px; min-height: 100vh; }
+    .trace-root { max-width: 1200px; margin: 0 auto; border-radius: 12px; overflow: hidden; }
+    pre { background: #0d1117; padding: 16px; border-radius: 8px; overflow-x: auto; }
+  </style>
+</head>
+<body>
+  <div class="trace-root" id="t"></div>
+  <script>
+    const commits = ${JSON.stringify(commits)};
+    let i = 0;
+    function render() {
+      const c = commits[i];
+      document.getElementById('t').innerHTML = \`
+        <div style="display:flex;height:600px;border:1px solid #1e293b;border-radius:8px">
+          <div style="width:250px;border-right:1px solid #1e293b;padding:16px;overflow-y:auto">
+            \${commits.map((c,j)=\`<div onclick="i=\${j}" style="padding:12px;cursor:pointer;border-left:2px solid transparent;\${i===j?'background:rgba(255,255,255,0.05);border-left-color:'+(c.authorType==='ai'?'#a78bfa':'#34d399'):'')">
+              <div style="display:flex;align-items:center;margin-bottom:4px">
+                <span style="width:8px;height:8px;border-radius:50%;background:\${c.authorType==='ai'?'#a78bfa':'#34d399'};margin-right:8px"></span>
+                <span style="font-size:13px">\${c.message.slice(0,30)}\${c.message.length>30?'...':''}</span>
+              </div>
+              <div style="font-size:11px;opacity:0.6">\${c.author} · \${c.time}</div>
+              <span style="font-size:9px;padding:2px 6px;border-radius:4px;background:\${c.authorType==='ai'?'rgba(167,139,250,0.15)':'rgba(52,211,153,0.15)'};color:\${c.authorType==='ai'?'#a78bfa':'#34d399'}">\${c.authorType}</span>
+            </div>\`).join('')}
+          </div>
+          <div style="flex:1;padding:16px;overflow-y:auto">
+            <h2 style="font-size:16px;margin:0 0 4px">\${c.message}</h2>
+            <div style="font-size:12px;opacity:0.6;margin-bottom:16px">\${c.hash} · \${c.author}</div>
+            <pre>\${c.lines.map(l=>\`<div style="\${l.type==='add'?'color:#34d399':l.type==='remove'?'color:#f87171':'opacity:0.5'}">\${l.content||' '}</div>\`).join('')}</pre>
+          </div>
+        </div>
+      \`;
+    }
+    render();
+  </script>
+</body>
+</html>`;
+}
+main().catch((err)=>{
+    console.error(`[trace] Error: ${err.message}`);
+    process.exit(1);
+});