git-trace 0.1.0

package/src/cache.ts

@@ -0,0 +1,118 @@
+// Local cache for GitHub API responses to avoid rate limits
+
+import type { Commit } from './types'
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+
+const CACHE_DIR = join(homedir(), '.trace-cache')
+const CACHE_TTL = 24 * 60 * 60 * 1000 // 24 hours
+
+export interface CacheEntry {
+  data: Commit[]
+  timestamp: number
+  repo: string
+  file: string
+  last: number
+}
+
+function sanitizePath(path: string): string {
+  // Remove ../, ./, and replace slashes with dashes
+  return path
+    .replace(/\.\.\//g, '')
+    .replace(/\.\//g, '')
+    .replace(/[\/\\]/g, '-')
+    .replace(/[^a-zA-Z0-9._-]/g, '_')
+}
+
+function getCacheKey(repo: string, file: string, last: number): string {
+  const key = `${sanitizePath(repo)}-${sanitizePath(file)}-${last}.json`
+  return join(CACHE_DIR, key)
+}
+
+export function getCached(repo: string, file: string, last: number): Commit[] | null {
+  const cachePath = getCacheKey(repo, file, last)
+
+  if (!existsSync(cachePath)) {
+    return null
+  }
+
+  try {
+    const content = readFileSync(cachePath, 'utf-8')
+    const entry: CacheEntry = JSON.parse(content)
+
+    // Check if cache is expired
+    const now = Date.now()
+    if (now - entry.timestamp > CACHE_TTL) {
+      return null
+    }
+
+    return entry.data
+  } catch {
+    return null
+  }
+}
+
+export function setCached(repo: string, file: string, last: number, data: Commit[]): void {
+  const cachePath = getCacheKey(repo, file, last)
+
+  try {
+    // Ensure cache directory exists
+    if (!existsSync(CACHE_DIR)) {
+      mkdirSync(CACHE_DIR, { recursive: true })
+    }
+
+    const entry: CacheEntry = {
+      data,
+      timestamp: Date.now(),
+      repo,
+      file,
+      last
+    }
+
+    writeFileSync(cachePath, JSON.stringify(entry, null, 2))
+  } catch {
+    // Silently fail - caching is optional
+  }
+}
+
+export function clearCache(): void {
+  try {
+    rmSync(CACHE_DIR, { recursive: true, force: true })
+  } catch {
+    // Ignore
+  }
+}
+
+export function getCacheSize(): number {
+  try {
+    if (!existsSync(CACHE_DIR)) return 0
+    const files = readdirSync(CACHE_DIR)
+    return files.length
+  } catch {
+    return 0
+  }
+}
+
+export function getCacheInfo(): CacheEntry[] {
+  try {
+    if (!existsSync(CACHE_DIR)) return []
+
+    const files = readdirSync(CACHE_DIR)
+    const entries: CacheEntry[] = []
+
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(CACHE_DIR, file), 'utf-8')
+        const entry: CacheEntry = JSON.parse(content)
+        entries.push(entry)
+      } catch {
+        // Skip invalid files
+      }
+    }
+
+    return entries
+  } catch {
+    return []
+  }
+}

package/src/config.ts

@@ -0,0 +1,51 @@
+// Config file support for .tracerc
+
+import { existsSync, readFileSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+import { DEFAULT_PATTERNS } from './patterns'
+
+export interface TraceConfig {
+  aiPatterns?: {
+    emails?: string[]
+    messages?: string[]
+  }
+  last?: number
+}
+
+const DEFAULT: TraceConfig = {
+  aiPatterns: DEFAULT_PATTERNS,
+  last: 10
+}
+
+let cached: TraceConfig | null = null
+
+export function loadConfig(cwd?: string): TraceConfig {
+  if (cached) return cached
+
+  const paths = cwd ? [join(cwd, '.tracerc'), join(homedir(), '.tracerc')] : [join(homedir(), '.tracerc')]
+
+  for (const path of paths) {
+    if (existsSync(path)) {
+      try {
+        const user = JSON.parse(readFileSync(path, 'utf-8'))
+        const merged: TraceConfig = { ...DEFAULT, ...user }
+        cached = merged
+        return cached
+      } catch {
+        // Invalid config, use defaults
+      }
+    }
+  }
+
+  cached = DEFAULT
+  return cached
+}
+
+export function getAIPatterns(config?: TraceConfig) {
+  const patterns = (config || loadConfig()).aiPatterns
+  return {
+    emails: patterns?.emails || DEFAULT.aiPatterns!.emails!,
+    messages: patterns?.messages || DEFAULT.aiPatterns!.messages!
+  }
+}

package/src/entries/config.ts

@@ -0,0 +1,7 @@
+// Config utilities — node only
+
+export {
+  loadConfig,
+  getAIPatterns
+} from '../config'
+export type { TraceConfig } from '../config'

package/src/entries/gitea.ts

@@ -0,0 +1,4 @@
+// Gitea adapter entry point
+
+export { fetchCommits } from '../gitea'
+export type { Commit } from '../types'

package/src/entries/github.ts

@@ -0,0 +1,5 @@
+// GitHub adapter entry point
+
+export { fetchCommits } from '../github'
+export { clearCache, getCacheSize } from '../cache'
+export type { Commit } from '../types'

package/src/entries/gitlab.ts

@@ -0,0 +1,4 @@
+// GitLab adapter entry point
+
+export { fetchCommits } from '../gitlab'
+export type { Commit } from '../types'

package/src/gitea.ts

@@ -0,0 +1,58 @@
+// Gitea API adapter — fetches commits with diffs from repositories
+
+import type { Commit } from './types'
+import { parseDiff, detectAI, formatRelativeTime, shortHash, firstLine } from './shared'
+
+const GITEA_API = 'https://gitea.com/api/v1'
+
+export async function fetchCommits(
+  owner: string,
+  repo: string,
+  file: string,
+  last: number = 10,
+  token?: string,
+  baseUrl?: string
+): Promise<Commit[]> {
+  const api = baseUrl || GITEA_API
+
+  const headers: Record<string, string> = { '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 = await 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 = await listRes.json()
+
+  // Fetch diffs in parallel
+  const results = await Promise.allSettled(
+    commitsList.map(async (c: any) => {
+      const diffUrl = `${api}/repos/${owner}/${repo}/git/commits/${c.sha}/diff`
+      const diffRes = await fetch(diffUrl, { headers })
+      if (!diffRes.ok) return null
+      const diffText = await diffRes.text()
+      return parseCommit(c, diffText)
+    })
+  )
+
+  return results
+    .map(r => r.status === 'fulfilled' ? r.value : null)
+    .filter((c): c is Commit => c !== null)
+}
+
+function parseCommit(data: any, diffText: string): Commit {
+  return {
+    hash: shortHash(data.sha),
+    message: firstLine(data.commit.message),
+    author: data.author?.login || data.commit.author?.name || 'Unknown',
+    authorType: detectAI(data.author?.login, data.commit.author?.email, data.commit.message),
+    time: formatRelativeTime(data.commit.author.date),
+    lines: parseDiff(diffText)
+  }
+}

package/src/github.ts

@@ -0,0 +1,100 @@
+// GitHub API adapter — fetches commits with diffs from repositories
+
+import type { Commit, GitHubCommit } from './types'
+import type { TraceConfig } from './config'
+import { getCached, setCached } from './cache'
+import { loadConfig, getAIPatterns } from './config'
+import { parseDiff, detectAI, formatRelativeTime, shortHash, firstLine } from './shared'
+
+const GITHUB_API = 'https://api.github.com'
+
+export async function fetchCommits(
+  owner: string,
+  repo: string,
+  file: string,
+  last: number = 10,
+  token?: string,
+  useCache: boolean = true,
+  onCacheHit?: () => void,
+  onCacheWrite?: () => void
+): Promise<Commit[]> {
+  const repoKey = `${owner}/${repo}`
+  const config = loadConfig()
+
+  // Check cache
+  if (useCache) {
+    const cached = getCached(repoKey, file, last)
+    if (cached) {
+      onCacheHit?.()
+      return cached as Commit[]
+    }
+  }
+
+  const headers: Record<string, string> = { '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 = await 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 = await listRes.json()
+
+  // Fetch diffs in parallel
+  const results = await Promise.allSettled(
+    commitsList.map(async (c: { sha: string }) => {
+      const commitUrl = `${GITHUB_API}/repos/${owner}/${repo}/commits/${c.sha}`
+      const commitRes = await fetch(commitUrl, { headers })
+      if (!commitRes.ok) return null
+      const detail = await commitRes.json() as GitHubCommit
+      return parseCommit(detail, config)
+    })
+  )
+
+  const commits = results
+    .map(r => r.status === 'fulfilled' ? r.value : null)
+    .filter((c): c is Commit => c !== null)
+
+  // Cache results
+  if (useCache && commits.length > 0) {
+    setCached(repoKey, file, last, commits)
+    onCacheWrite?.()
+  }
+
+  return commits
+}
+
+export { clearCache, getCacheSize } from './cache'
+
+function parseCommit(data: GitHubCommit, config?: TraceConfig): Commit {
+  const lines: Commit['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?.login || data.commit.author?.name || 'Unknown',
+    authorType: detectAI(
+      data.author?.login,
+      data.commit.author?.email,
+      data.commit.message,
+      aiPatterns
+    ),
+    time: formatRelativeTime(data.commit.author.date),
+    lines
+  }
+}

package/src/gitlab.ts

@@ -0,0 +1,65 @@
+// GitLab API adapter — fetches commits with diffs from repositories
+
+import type { Commit } from './types'
+import { parseDiff, detectAI, formatRelativeTime, shortHash, firstLine } from './shared'
+
+const GITLAB_API = 'https://gitlab.com/api/v4'
+
+export async function fetchCommits(
+  owner: string,
+  repo: string,
+  file: string,
+  last: number = 10,
+  token?: string,
+  baseUrl?: string
+): Promise<Commit[]> {
+  const api = baseUrl || GITLAB_API
+  const projectId = encodeURIComponent(`${owner}/${repo}`)
+
+  const headers: Record<string, string> = {}
+  if (token) headers['PRIVATE-TOKEN'] = token
+
+  // Fetch commits list
+  const listUrl = `${api}/projects/${projectId}/repository/commits?path=${encodeURIComponent(file)}&per_page=${last}`
+  const listRes = await 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 = await listRes.json()
+
+  // Fetch diffs in parallel
+  const results = await Promise.allSettled(
+    commitsList.map(async (c: any) => {
+      const diffUrl = `${api}/projects/${projectId}/repository/commits/${c.id}/diff?per_page=100`
+      const diffRes = await fetch(diffUrl, { headers })
+      if (!diffRes.ok) return null
+      const diff = await diffRes.json()
+      return parseCommit(c, diff)
+    })
+  )
+
+  return results
+    .map(r => r.status === 'fulfilled' ? r.value : null)
+    .filter((c): c is Commit => c !== null)
+}
+
+function parseCommit(data: any, diffData: any[]): Commit {
+  const lines: Commit['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
+  }
+}

package/src/highlight/highlight.ts

@@ -0,0 +1,119 @@
+// Syntax highlighting using sugar-high (~1KB, zero dependencies)
+
+import { highlight } from 'sugar-high'
+
+const MAX_CACHE_SIZE = 100
+
+/**
+ * Simple LRU (Least Recently Used) cache implementation
+ * Evicts oldest entries when capacity is reached
+ */
+export class LRUCache<K, V> {
+  private cache = new Map<K, V>()
+
+  get(key: K): V | undefined {
+    if (!this.cache.has(key)) return undefined
+    const value = this.cache.get(key)!
+    // Move to end (most recently used)
+    this.cache.delete(key)
+    this.cache.set(key, value)
+    return value
+  }
+
+  set(key: K, value: V): void {
+    // Remove oldest entry if at capacity
+    if (this.cache.size >= MAX_CACHE_SIZE) {
+      const firstKey = this.cache.keys().next().value as K | undefined
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey)
+      }
+    }
+    this.cache.set(key, value)
+  }
+
+  clear(): void {
+    this.cache.clear()
+  }
+}
+
+// LRU cache for highlighted code to avoid re-calculating
+const highlightCache = new LRUCache<string, string>()
+
+/**
+ * Highlight code using sugar-high
+ * Returns HTML string with token classes (sh__token--*)
+ * Results are cached for performance - same input produces same output
+ *
+ * SECURITY: sugar-high tokenizes code but does NOT escape HTML.
+ * Caller must escape user input BEFORE calling this function.
+ */
+export function highlightCode(code: string): string {
+  if (!code) return ''
+
+  const cached = highlightCache.get(code)
+  if (cached) return cached
+
+  const result = highlight(code)
+  highlightCache.set(code, result)
+  return result
+}
+
+/**
+ * Clear the highlight cache (useful for testing or memory management)
+ */
+export function clearHighlightCache(): void {
+  highlightCache.clear()
+}
+
+/**
+ * Get language from file extension
+ * Useful for language-specific handling
+ */
+const LANGUAGE_MAP: Record<string, string> = {
+  'js': 'javascript',
+  'jsx': 'javascript',
+  'ts': 'typescript',
+  'tsx': 'typescript',
+  'py': 'python',
+  'rs': 'rust',
+  'go': 'go',
+  'java': 'java',
+  'c': 'c',
+  'h': 'c',
+  'cpp': 'cpp',
+  'cc': 'cpp',
+  'cxx': 'cpp',
+  'hpp': 'cpp',
+  'cs': 'csharp',
+  'php': 'php',
+  'rb': 'ruby',
+  'swift': 'swift',
+  'kt': 'kotlin',
+  'scala': 'scala',
+  'sh': 'shell',
+  'bash': 'shell',
+  'zsh': 'shell',
+  'fish': 'shell',
+  'json': 'json',
+  'yaml': 'yaml',
+  'yml': 'yaml',
+  'toml': 'toml',
+  'xml': 'xml',
+  'html': 'html',
+  'htm': 'html',
+  'css': 'css',
+  'scss': 'scss',
+  'sass': 'sass',
+  'md': 'markdown',
+  'mdx': 'markdown',
+  'sql': 'sql',
+  'graphql': 'graphql',
+  'gql': 'graphql',
+  'vue': 'vue',
+  'svelte': 'svelte'
+}
+
+export function getLanguageFromPath(filePath: string): string {
+  const ext = filePath.split('.').pop()?.toLowerCase()
+  return LANGUAGE_MAP[ext || ''] || 'text'
+}

package/src/highlight/index.ts

@@ -0,0 +1,4 @@
+// Syntax highlighting module — optional import for enhanced diff display
+
+export { highlightCode, clearHighlightCache, getLanguageFromPath } from './highlight'
+export type { LRUCache } from './highlight'

package/src/host.ts

@@ -0,0 +1,32 @@
+// Git host detection for CLI — auto-detects GitHub, GitLab, Gitea from repo strings
+
+export type GitHost = 'github' | 'gitlab' | 'gitea'
+
+export interface DetectedHost {
+  host: GitHost
+  owner: string
+  repo: string
+}
+
+// Detect host from repo URL or owner/repo string
+export function detectHost(input: string): DetectedHost | null {
+  // 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
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+// Core component — zero dependency, browser-safe
+// Syntax highlighting available as optional import: import 'trace/highlight'
+
+export { Trace } from './Trace'
+export { themes, themeToVars } from './themes'
+export type { Commit, DiffLine, TraceProps, Theme, ThemeColors, FilterOptions, AuthorTypeFilter } from './types'

package/src/patterns.ts

@@ -0,0 +1,6 @@
+// Default AI detection patterns — browser-safe, no Node.js dependencies
+
+export 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']
+}