@devtrace-ai/cli 1.0.0

package/dist/html_report.js

@@ -0,0 +1,325 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeHtml = escapeHtml;
+exports.toolLabel = toolLabel;
+exports.tierLabel = tierLabel;
+exports.buildHtmlReport = buildHtmlReport;
+exports.writeHtmlReport = writeHtmlReport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+/** Escapes a user-controlled string for safe embedding in HTML text/attribute contexts. */
+function escapeHtml(input) {
+    return String(input)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+/** Human-readable label for an AITool key (matches index.ts's reveal-box toolLabel). */
+function toolLabel(tool) {
+    const labels = {
+        'claude-code': 'Claude',
+        'gemini-cli': 'Gemini',
+        'cursor': 'Cursor',
+        'copilot': 'Copilot',
+        'codex': 'Codex',
+        'aider': 'Aider',
+        'ollama': 'Ollama',
+        'other': 'Other AI',
+        'unknown-ai': 'Unknown AI (heuristic)',
+        'none': 'Human'
+    };
+    return labels[tool] || tool;
+}
+/** Honest, spelled-out confidence-tier description for the by-tool table. Never inflates trust. */
+function tierLabel(tier) {
+    switch (tier) {
+        case 1: return 'confirmed — commit trailer';
+        case 2: return 'corroborated';
+        case 3: return 'heuristic — weak prior';
+        case 0:
+        default:
+            return 'unknown';
+    }
+}
+/** The weakest (least-confident) tier present in a group, so the table never overstates confidence. */
+function dominantTier(sessions) {
+    const tiers = sessions.map(s => s.aiToolTier).filter((t) => t !== undefined);
+    if (tiers.length === 0)
+        return undefined;
+    return Math.min(...tiers);
+}
+function fmtPct(rate) {
+    if (rate === null || rate === undefined)
+        return 'unknown';
+    return `${(rate * 100).toFixed(0)}%`;
+}
+function survival30dLabel(w) {
+    if (!w)
+        return '—';
+    if (w.status === 'measured')
+        return `${(w.rate * 100).toFixed(0)}%`;
+    if (w.status === 'window-open')
+        return 'window open';
+    return 'unknown';
+}
+/** Insertion-weighted average survival rate across sessions with a numeric churn.survivalRate. */
+function weightedSurvivalRate(sessions) {
+    let totalInsertions = 0;
+    let totalSurviving = 0;
+    let anyKnown = false;
+    for (const s of sessions) {
+        if (!s.churn || s.diff.totalInsertions <= 0)
+            continue;
+        anyKnown = true;
+        totalInsertions += s.diff.totalInsertions;
+        totalSurviving += s.diff.totalInsertions * s.churn.survivalRate;
+    }
+    if (!anyKnown || totalInsertions === 0)
+        return null;
+    return totalSurviving / totalInsertions;
+}
+function weightedSurvival30d(sessions) {
+    const measured = sessions
+        .map(s => s.churn?.survival30d)
+        .filter((v) => v !== undefined && v.status === 'measured');
+    if (measured.length === 0)
+        return null;
+    const rate = measured.reduce((sum, v) => sum + v.rate, 0) / measured.length;
+    return { rate, n: measured.length };
+}
+/** Builds a minimal, hand-rendered inline SVG bar chart of commits/day (AI vs human stacked). */
+function buildTrendSvg(stats) {
+    const dates = Object.keys(stats.timeline).sort();
+    if (dates.length === 0) {
+        return '<p class="muted">No timeline data yet.</p>';
+    }
+    const width = 720;
+    const height = 160;
+    const paddingLeft = 30;
+    const paddingBottom = 20;
+    const plotWidth = width - paddingLeft - 10;
+    const plotHeight = height - paddingBottom - 10;
+    const barGap = 2;
+    const barWidth = Math.max(1, plotWidth / dates.length - barGap);
+    const maxTotal = Math.max(1, ...dates.map(d => stats.timeline[d].total));
+    let bars = '';
+    dates.forEach((d, i) => {
+        const day = stats.timeline[d];
+        const x = paddingLeft + i * (barWidth + barGap);
+        const aiH = (day.ai / maxTotal) * plotHeight;
+        const humanH = (day.human / maxTotal) * plotHeight;
+        const baseY = 10 + plotHeight;
+        const humanY = baseY - humanH;
+        const aiY = humanY - aiH;
+        if (day.human > 0) {
+            bars += `<rect x="${x.toFixed(1)}" y="${humanY.toFixed(1)}" width="${barWidth.toFixed(1)}" height="${humanH.toFixed(1)}" fill="#64748b"><title>${escapeHtml(d)}: ${day.human} human commit(s)</title></rect>`;
+        }
+        if (day.ai > 0) {
+            bars += `<rect x="${x.toFixed(1)}" y="${aiY.toFixed(1)}" width="${barWidth.toFixed(1)}" height="${aiH.toFixed(1)}" fill="#22d3ee"><title>${escapeHtml(d)}: ${day.ai} AI commit(s)</title></rect>`;
+        }
+    });
+    const axisY = 10 + plotHeight;
+    return `<svg viewBox="0 0 ${width} ${height}" width="100%" height="${height}" role="img" aria-label="Commits over time, AI vs human">
+    <line x1="${paddingLeft}" y1="${axisY}" x2="${width - 10}" y2="${axisY}" stroke="#475569" stroke-width="1"/>
+    ${bars}
+    <text x="${paddingLeft}" y="12" fill="#94a3b8" font-size="10">${escapeHtml(String(maxTotal))} max/day</text>
+    <text x="${paddingLeft}" y="${height - 4}" fill="#94a3b8" font-size="10">${escapeHtml(dates[0])}</text>
+    <text x="${width - 90}" y="${height - 4}" fill="#94a3b8" font-size="10">${escapeHtml(dates[dates.length - 1])}</text>
+  </svg>`;
+}
+/** Builds the ONE self-contained local HTML report for `devtrace report`. */
+function buildHtmlReport(stats, sessions, projectDir) {
+    const repoName = escapeHtml(path.basename(projectDir));
+    const generatedAt = new Date().toISOString();
+    const aiSessions = sessions.filter(s => s.aiTool !== 'none');
+    const humanSessions = sessions.filter(s => s.aiTool === 'none');
+    const headSurvivalAi = weightedSurvivalRate(aiSessions);
+    const headSurvivalHuman = weightedSurvivalRate(humanSessions);
+    const w30 = weightedSurvival30d(aiSessions);
+    const aiSharePct = stats.totalCommits > 0 ? ((stats.aiCommits / stats.totalCommits) * 100).toFixed(0) : '0';
+    // By-tool table
+    const byToolRows = [];
+    const byTool = new Map();
+    for (const s of sessions) {
+        if (!byTool.has(s.aiTool))
+            byTool.set(s.aiTool, []);
+        byTool.get(s.aiTool).push(s);
+    }
+    for (const [tool, toolSessions] of byTool.entries()) {
+        if (toolSessions.length === 0)
+            continue;
+        const rate = weightedSurvivalRate(toolSessions);
+        const w = weightedSurvival30d(toolSessions);
+        const tier = dominantTier(toolSessions);
+        byToolRows.push(`<tr>
+      <td>${escapeHtml(toolLabel(tool))}</td>
+      <td>${toolSessions.length}</td>
+      <td>${escapeHtml(fmtPct(rate))}</td>
+      <td>${w ? escapeHtml(`${(w.rate * 100).toFixed(0)}% (n=${w.n})`) : '—'}</td>
+      <td class="tier">${escapeHtml(tierLabel(tier))}</td>
+    </tr>`);
+    }
+    // Per-commit table (most recent first)
+    const commitRows = [...sessions].reverse().map(s => {
+        const hash = escapeHtml(s.commitHash.substring(0, 8));
+        const date = escapeHtml(s.timestamp.substring(0, 10));
+        const tool = escapeHtml(toolLabel(s.aiTool));
+        const tier = escapeHtml(tierLabel(s.aiToolTier));
+        const lines = escapeHtml(`+${s.diff.totalInsertions}/-${s.diff.totalDeletions}`);
+        const survival = escapeHtml(s.churn ? fmtPct(s.churn.survivalRate) : '—');
+        const survival30 = escapeHtml(survival30dLabel(s.churn?.survival30d));
+        const branch = escapeHtml(s.branchName);
+        return `<tr>
+      <td><code>${hash}</code></td>
+      <td>${date}</td>
+      <td>${tool}</td>
+      <td class="tier">${tier}</td>
+      <td>${lines}</td>
+      <td>${survival}</td>
+      <td>${survival30}</td>
+      <td><code>${branch}</code></td>
+    </tr>`;
+    }).join('\n');
+    const trendSvg = buildTrendSvg(stats);
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>DevTrace Report — ${repoName}</title>
+<style>
+  :root { color-scheme: dark; }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0; padding: 2rem 1.5rem 4rem;
+    background: #0f172a; color: #e2e8f0;
+    font: 15px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  }
+  .wrap { max-width: 960px; margin: 0 auto; }
+  h1 { font-size: 1.6rem; margin-bottom: 0.1rem; }
+  .subtitle { color: #94a3b8; margin-bottom: 2rem; font-size: 0.9rem; }
+  h2 { font-size: 1.1rem; margin-top: 2.5rem; border-bottom: 1px solid #334155; padding-bottom: 0.4rem; }
+  .headline-grid { display: flex; gap: 1rem; flex-wrap: wrap; margin: 1rem 0; }
+  .stat-card {
+    background: #1e293b; border: 1px solid #334155; border-radius: 10px;
+    padding: 1rem 1.25rem; min-width: 180px; flex: 1;
+  }
+  .stat-card .label { color: #94a3b8; font-size: 0.8rem; text-transform: uppercase; letter-spacing: 0.04em; }
+  .stat-card .value { font-size: 1.8rem; font-weight: 600; margin-top: 0.25rem; }
+  .stat-card .footnote { color: #64748b; font-size: 0.75rem; margin-top: 0.25rem; }
+  table { width: 100%; border-collapse: collapse; margin: 1rem 0; font-size: 0.85rem; }
+  th, td { text-align: left; padding: 0.45rem 0.6rem; border-bottom: 1px solid #1e293b; }
+  th { color: #94a3b8; font-weight: 600; font-size: 0.75rem; text-transform: uppercase; letter-spacing: 0.03em; }
+  tr:hover { background: #1e293b; }
+  code { background: #1e293b; padding: 0.1rem 0.35rem; border-radius: 4px; font-size: 0.85em; }
+  td.tier { color: #94a3b8; font-size: 0.8rem; }
+  .muted { color: #64748b; }
+  .table-scroll { overflow-x: auto; }
+  .trend-box { background: #1e293b; border: 1px solid #334155; border-radius: 10px; padding: 1rem; }
+  footer { margin-top: 3rem; color: #475569; font-size: 0.75rem; }
+</style>
+</head>
+<body>
+<div class="wrap">
+  <h1>DevTrace Report — ${repoName}</h1>
+  <div class="subtitle">Generated ${escapeHtml(generatedAt)} · ${stats.totalCommits} traced commit(s)</div>
+
+  <h2>Headline survival</h2>
+  <div class="headline-grid">
+    <div class="stat-card">
+      <div class="label">AI lines still at HEAD</div>
+      <div class="value">${escapeHtml(fmtPct(headSurvivalAi))}</div>
+      <div class="footnote">${aiSessions.length} AI commit(s)</div>
+    </div>
+    <div class="stat-card">
+      <div class="label">Human lines still at HEAD</div>
+      <div class="value">${escapeHtml(fmtPct(headSurvivalHuman))}</div>
+      <div class="footnote">${humanSessions.length} human commit(s)</div>
+    </div>
+    <div class="stat-card">
+      <div class="label">AI lines surviving 30 days</div>
+      <div class="value">${w30 ? escapeHtml(`${(w30.rate * 100).toFixed(0)}%`) : 'unknown'}</div>
+      <div class="footnote">${w30 ? `n=${w30.n} commit(s) measured` : 'no commits old enough to measure yet'}</div>
+    </div>
+    <div class="stat-card">
+      <div class="label">AI vs human commit share</div>
+      <div class="value">${escapeHtml(aiSharePct)}%</div>
+      <div class="footnote">${stats.aiCommits} AI / ${stats.humanCommits} human</div>
+    </div>
+  </div>
+
+  <h2>By tool</h2>
+  <div class="table-scroll">
+  <table>
+    <thead><tr><th>Tool</th><th>Commits</th><th>Survival (HEAD)</th><th>Survival (30d)</th><th>Confidence</th></tr></thead>
+    <tbody>${byToolRows.join('\n') || '<tr><td colspan="5" class="muted">No sessions recorded.</td></tr>'}</tbody>
+  </table>
+  </div>
+
+  <h2>Trend over time</h2>
+  <div class="trend-box">${trendSvg}</div>
+
+  <h2>Commits</h2>
+  <div class="table-scroll">
+  <table>
+    <thead><tr><th>Hash</th><th>Date</th><th>Tool</th><th>Confidence</th><th>Lines</th><th>Survival (HEAD)</th><th>Survival (30d)</th><th>Branch</th></tr></thead>
+    <tbody>${commitRows || '<tr><td colspan="8" class="muted">No sessions recorded.</td></tr>'}</tbody>
+  </table>
+  </div>
+
+  <footer>Generated by DevTrace — measured from local git history. Heuristic detections (tier 3) are weak priors, not proof.</footer>
+</div>
+</body>
+</html>
+`;
+}
+/** Writes the HTML report to disk and returns the absolute path. */
+function writeHtmlReport(stats, sessions, projectDir, outPath) {
+    const config = config_1.ConfigManager.loadConfig(projectDir);
+    const target = outPath
+        ? path.resolve(projectDir, outPath)
+        : path.join(projectDir, config.storageDir, 'report.html');
+    const dir = path.dirname(target);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const html = buildHtmlReport(stats, sessions, projectDir);
+    fs.writeFileSync(target, html, 'utf8');
+    return target;
+}

package/dist/ignore.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IgnoreFilter = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class IgnoreFilter {
+    rules = [];
+    projectDir;
+    // Default lockfiles and common ignore paths
+    static defaultPatterns = [
+        'package-lock.json',
+        'yarn.lock',
+        'pnpm-lock.yaml',
+        'bun.lockb',
+        'node_modules/**',
+        '.devtrace/**',
+        '.git/**',
+    ];
+    constructor(projectDir = process.cwd(), customStorageDir) {
+        this.projectDir = path.resolve(projectDir);
+        // 1. Add defaults
+        for (const pattern of IgnoreFilter.defaultPatterns) {
+            this.rules.push(this.compileGlob(pattern));
+        }
+        if (customStorageDir) {
+            this.rules.push(this.compileGlob(`${customStorageDir}/**`));
+        }
+        // 2. Load .devtraceignore if exists
+        const ignorePath = path.join(this.projectDir, '.devtraceignore');
+        if (fs.existsSync(ignorePath)) {
+            try {
+                const content = fs.readFileSync(ignorePath, 'utf8');
+                const lines = content.split(/\r?\n/);
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (trimmed && !trimmed.startsWith('#')) {
+                        this.rules.push(this.compileGlob(trimmed));
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`[DevTrace] Failed to load .devtraceignore: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Evaluates if a file path matches ignore rules.
+     */
+    shouldIgnore(filepath) {
+        let relativePath = filepath;
+        if (path.isAbsolute(filepath)) {
+            relativePath = path.relative(this.projectDir, filepath);
+        }
+        // Normalize path separators
+        const normalized = relativePath.replace(/\\/g, '/');
+        return this.rules.some(rule => rule.test(normalized));
+    }
+    /**
+     * Compiles simple globs into regexes without external dependencies.
+     */
+    compileGlob(glob) {
+        // Clean up pattern: remove leading/trailing slashes
+        let cleaned = glob.trim().replace(/\\/g, '/');
+        // If it starts with a slash, anchor it at root. Otherwise allow it anywhere in the path.
+        const rootAnchored = cleaned.startsWith('/');
+        if (rootAnchored) {
+            cleaned = cleaned.substring(1);
+        }
+        // Convert wildcards
+        // Escape regex special chars except * and ?
+        let regexStr = cleaned
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape regex characters
+            .replace(/\*\*/g, '@@') // temporarily label double star
+            .replace(/\*/g, '[^/]*') // single star matches anything except slash
+            .replace(/\?/g, '[^/]') // question mark matches single character except slash
+            .replace(/@@/g, '.*'); // restore double star to match anything including slash
+        // If it's a directory (ends with slash or matches a directory name), allow trailing matches
+        if (cleaned.endsWith('/')) {
+            regexStr = regexStr + '.*';
+        }
+        else {
+            // If it matches a directory name (e.g. "dist"), also allow "dist/*"
+            regexStr = `(?:${regexStr}|${regexStr}/.*)`;
+        }
+        if (rootAnchored) {
+            return new RegExp(`^${regexStr}$`);
+        }
+        else {
+            return new RegExp(`(?:^|/)${regexStr}$`);
+        }
+    }
+}
+exports.IgnoreFilter = IgnoreFilter;