@h5l0/codelens 0.1.0

package/dist/cli/server.js

@@ -0,0 +1,165 @@
+// ---------------------------------------------------------------------------
+// 本地托管
+// 用 node 内置 http 提供静态页面与两份数据接口，API 中间件同时供 Vite 开发服务器复用。
+// ---------------------------------------------------------------------------
+import { createReadStream, statSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { extname, join, resolve, sep } from 'node:path';
+const MIME = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.mjs': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.ico': 'image/x-icon',
+    '.woff2': 'font/woff2',
+    '.wasm': 'application/wasm',
+    '.map': 'application/json; charset=utf-8',
+};
+function sendJson(res, body) {
+    res.writeHead(200, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(body),
+        // 数据每次启动重新生成，禁用缓存避免看到旧结果
+        'cache-control': 'no-store',
+    });
+    res.end(body);
+}
+function sendText(res, status, body) {
+    res.writeHead(status, { 'content-type': 'text/plain; charset=utf-8' });
+    res.end(body);
+}
+/**
+ * 取出请求的路径。畸形 URL（例如 `/%`）只该让这一个请求失败，
+ * 不能让整个进程崩掉，所以这里返回 undefined 交给调用方回 400。
+ */
+function pathnameOf(req) {
+    try {
+        return new URL(req.url ?? '/', 'http://localhost').pathname;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 数据接口：/api/data.json 是改动日历，/api/loc.json 是行数清单。 */
+export function createApiMiddleware(payloads) {
+    return (req, res, next) => {
+        const pathname = pathnameOf(req);
+        if (pathname === undefined) {
+            sendText(res, 400, 'bad request');
+            return;
+        }
+        if (pathname === '/api/data.json' || pathname === '/data.json') {
+            sendJson(res, payloads.data);
+            return;
+        }
+        if (pathname === '/api/loc.json' || pathname === '/loc.json') {
+            sendJson(res, payloads.loc);
+            return;
+        }
+        next();
+    };
+}
+/** 静态资源：把构建产物目录当作站点根。 */
+export function createStaticMiddleware(webDir) {
+    return (req, res, next) => {
+        const rawPath = pathnameOf(req);
+        if (rawPath === undefined) {
+            sendText(res, 400, 'bad request');
+            return;
+        }
+        let pathname;
+        try {
+            pathname = decodeURIComponent(rawPath);
+        }
+        catch {
+            sendText(res, 400, 'bad request: malformed percent-encoding in the url');
+            return;
+        }
+        const rel = pathname === '/' ? 'index.html' : pathname.replace(/^\/+/, '');
+        let filePath = resolve(webDir, rel);
+        if (filePath !== webDir && !filePath.startsWith(webDir + sep)) {
+            sendText(res, 403, 'path escapes the site root');
+            return;
+        }
+        try {
+            if (statSync(filePath).isDirectory()) {
+                filePath = join(filePath, 'index.html');
+                statSync(filePath);
+            }
+        }
+        catch {
+            next();
+            return;
+        }
+        const { size } = statSync(filePath);
+        res.writeHead(200, {
+            'content-type': MIME[extname(filePath).toLowerCase()] ?? 'application/octet-stream',
+            'content-length': size,
+            'cache-control': 'no-store',
+        });
+        if (req.method === 'HEAD') {
+            res.end();
+            return;
+        }
+        createReadStream(filePath).pipe(res);
+    };
+}
+export function compose(middlewares) {
+    return (req, res, next) => {
+        let index = 0;
+        const step = () => {
+            const middleware = middlewares[index];
+            index += 1;
+            if (!middleware) {
+                next();
+                return;
+            }
+            middleware(req, res, step);
+        };
+        step();
+    };
+}
+const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '::1', '[::1]']);
+/** 是否只有本机能访问；否则页面对同网段的机器也是开放的。 */
+export function isLoopbackHost(host) {
+    return LOOPBACK_HOSTS.has(host);
+}
+/** 打印用的地址：监听全部网卡时换成本机名，IPv6 补上方括号。 */
+export function displayHost(host) {
+    if (host === '0.0.0.0' || host === '::' || host === '[::]') {
+        return 'localhost';
+    }
+    return host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+}
+export function startServer(middleware, opts) {
+    const handler = compose([middleware]);
+    const server = createServer((req, res) => {
+        handler(req, res, () => sendText(res, 404, `not found: ${req.url ?? '/'}`));
+    });
+    const listen = (port, left) => new Promise((done, fail) => {
+        const onError = (err) => {
+            server.removeListener('error', onError);
+            if (err.code === 'EADDRINUSE' && left > 0) {
+                done(listen(port + 1, left - 1));
+                return;
+            }
+            fail(err);
+        };
+        server.once('error', onError);
+        server.listen(port, opts.host, () => {
+            server.removeListener('error', onError);
+            // port 为 0 时由系统分配，要取真实端口，否则打印出来的地址打不开
+            const address = server.address();
+            done(typeof address === 'object' && address !== null ? address.port : port);
+        });
+    });
+    return listen(opts.port, opts.attempts ?? 10).then((port) => ({
+        port,
+        url: `http://${displayHost(opts.host)}:${port}/`,
+        close: () => server.close(),
+    }));
+}

package/dist/core/calendar.js

@@ -0,0 +1,178 @@
+// ---------------------------------------------------------------------------
+// 改动日历
+// 用 git log --numstat 流式读出最近一段时间的提交，按文件的路径归属拆到各分组。
+// 日期统一取 committer date，与 git log --since 的过滤口径一致；在子目录里运行时
+// 加 --relative，路径与统计范围都和行数视图对齐。
+// ---------------------------------------------------------------------------
+import { execFileSync, spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { firstMatch } from './glob.js';
+import { createPathFilter, GIT_SAFE_CONFIG } from './scan.js';
+import { repoName } from './util.js';
+const COMMIT_PREFIX = 'COMMIT|';
+function emptyStats() {
+    return { commits: 0, add: 0, del: 0 };
+}
+function blankGroups(groups) {
+    const out = { all: emptyStats() };
+    for (const group of groups) {
+        out[group.id] = emptyStats();
+    }
+    return out;
+}
+/** 目录是否在 git 仓库内，用于提前给出可读的提示。 */
+export function isGitRepo(root) {
+    try {
+        const out = execFileSync('git', ['-C', root, ...GIT_SAFE_CONFIG, 'rev-parse', '--is-inside-work-tree'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return out.trim() === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+/** 逐行读 git 的输出：历史很大时不会像一次性读入那样撞上 maxBuffer。 */
+async function streamLines(args, onLine) {
+    const child = spawn('git', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stderr = '';
+    child.stderr.on('data', (chunk) => {
+        if (stderr.length < 4096) {
+            stderr += chunk.toString('utf8');
+        }
+    });
+    try {
+        const done = new Promise((resolve, reject) => {
+            child.on('error', reject);
+            child.on('close', resolve);
+        });
+        const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+        for await (const line of lines) {
+            onLine(line);
+        }
+        const code = await done;
+        if (code !== 0) {
+            throw new Error(stderr.trim() || `git exited with code ${code}`);
+        }
+    }
+    finally {
+        child.kill();
+    }
+}
+export async function buildCalendar(root, profile, opts) {
+    const args = ['-C', root, ...GIT_SAFE_CONFIG, '-c', 'core.quotePath=false', 'log'];
+    if (opts.days > 0) {
+        args.push(`--since=${opts.days} days ago`);
+    }
+    args.push('--relative', '--date=short', '--no-renames', `--pretty=format:${COMMIT_PREFIX}%cd|%h|%s`, '--numstat');
+    const counted = createPathFilter(profile.ignore);
+    const days = new Map();
+    let current = null;
+    let currentGroups = null;
+    let touched = false;
+    const flush = () => {
+        if (!current) {
+            return;
+        }
+        const { date, groups, ...rest } = current;
+        // 合并提交、空提交没有任何文件行，也要计入 all，
+        // 否则统计卡的提交数与下方提交列表对不上
+        if (!touched) {
+            groups.all.commits = 1;
+        }
+        const entry = { ...rest, groups };
+        const day = days.get(date) ?? { commits: [], groups: blankGroups(profile.groups) };
+        day.commits.push(entry);
+        for (const [id, stat] of Object.entries(groups)) {
+            const target = day.groups[id] ?? emptyStats();
+            target.commits += stat.commits;
+            target.add += stat.add;
+            target.del += stat.del;
+            day.groups[id] = target;
+        }
+        days.set(date, day);
+        current = null;
+        currentGroups = null;
+        touched = false;
+    };
+    await streamLines(args, (line) => {
+        if (line === '') {
+            return;
+        }
+        if (line.startsWith(COMMIT_PREFIX)) {
+            flush();
+            const parts = line.slice(COMMIT_PREFIX.length).split('|');
+            current = {
+                date: parts[0],
+                hash: parts[1],
+                subject: parts.slice(2).join('|'),
+                groups: blankGroups(profile.groups),
+            };
+            currentGroups = current.groups;
+            return;
+        }
+        const parts = line.split('\t');
+        if (parts.length < 3 || !current || !currentGroups) {
+            return;
+        }
+        const path = parts.slice(2).join('\t');
+        if (!counted(path)) {
+            // 与行数视图共用一套忽略口径，两个视图的分母才对得上
+            return;
+        }
+        const add = parts[0] === '-' ? 0 : Number.parseInt(parts[0], 10);
+        const del = parts[1] === '-' ? 0 : Number.parseInt(parts[1], 10);
+        if (Number.isNaN(add) || Number.isNaN(del)) {
+            return;
+        }
+        touched = true;
+        const groupId = firstMatch(path, profile.groups);
+        for (const id of groupId ? ['all', groupId] : ['all']) {
+            const stat = currentGroups[id];
+            stat.add += add;
+            stat.del += del;
+            // 同一个提交里改多个文件只算一次；改动行数为 0（二进制、仅改权限）也算改过
+            stat.commits = 1;
+        }
+    });
+    flush();
+    const dates = [...days.keys()].sort();
+    const totals = blankGroups(profile.groups);
+    let maxVal = 1;
+    let maxCommits = 1;
+    for (const day of days.values()) {
+        for (const [id, stat] of Object.entries(day.groups)) {
+            totals[id].add += stat.add;
+            totals[id].del += stat.del;
+            totals[id].commits += stat.commits;
+        }
+        maxVal = Math.max(maxVal, day.groups.all.add, day.groups.all.del);
+        maxCommits = Math.max(maxCommits, day.groups.all.commits);
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        root: repoName(root),
+        profile: profile.name,
+        groups: profile.groups.map(({ id, label, labelKey, hue, sat }) => ({ id, label, labelKey, hue, sat })),
+        range: { min: dates[0] ?? '', max: dates[dates.length - 1] ?? '' },
+        totals: { days: dates.length, groups: totals },
+        maxVal,
+        maxCommits,
+        days: Object.fromEntries(dates.map((date) => [date, days.get(date)])),
+    };
+}
+/** git 不可用或目录不是仓库时的空日历，让页面的其余部分仍可用。 */
+export function emptyCalendar(root, profile) {
+    return {
+        generatedAt: new Date().toISOString(),
+        root: repoName(root),
+        profile: profile.name,
+        groups: profile.groups.map(({ id, label, labelKey, hue, sat }) => ({ id, label, labelKey, hue, sat })),
+        range: { min: '', max: '' },
+        totals: { days: 0, groups: blankGroups(profile.groups) },
+        maxVal: 1,
+        maxCommits: 1,
+        days: {},
+    };
+}

package/dist/core/gitignore.js

@@ -0,0 +1,65 @@
+// ---------------------------------------------------------------------------
+// .gitignore 解析与匹配
+// git 可用时直接由 git 过滤，这里的实现用于 git 缺失或非仓库目录的情形。
+// 语义与 git 一致：后出现的规则覆盖先出现的，`!` 表示反向排除，
+// 结尾 `/` 只匹配目录，含 `/` 的模式从所在目录锚定。
+// ---------------------------------------------------------------------------
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createGlob } from './glob.js';
+function parseLine(raw, base) {
+    // 行尾未转义的空格在 gitignore 里被忽略
+    const line = raw.replace(/(?<!\\)\s+$/, '');
+    if (line === '' || line.startsWith('#')) {
+        return undefined;
+    }
+    const negate = line.startsWith('!');
+    let pattern = negate ? line.slice(1) : line;
+    // 反斜杠加空格是转义的空格，还原成普通空格
+    pattern = pattern.replace(/\\ /g, ' ');
+    const dirOnly = pattern.endsWith('/');
+    if (dirOnly) {
+        pattern = pattern.slice(0, -1);
+    }
+    if (pattern === '') {
+        return undefined;
+    }
+    // 开头的 `/` 由 createGlob 解释为从所在目录起算，这里原样传下去
+    if (pattern === '') {
+        return undefined;
+    }
+    return { base, negate, dirOnly, test: createGlob(pattern, base) };
+}
+/** 解析一段 .gitignore 文本，base 为该文件所在目录。 */
+export function parseIgnoreText(text, base) {
+    const rules = [];
+    for (const raw of text.split(/\r?\n/)) {
+        const rule = parseLine(raw, base);
+        if (rule) {
+            rules.push(rule);
+        }
+    }
+    return rules;
+}
+/** 读取目录下的 .gitignore，不存在时返回空数组。 */
+export function loadIgnoreFile(dir, base) {
+    try {
+        return parseIgnoreText(readFileSync(join(dir, '.gitignore'), 'utf8'), base);
+    }
+    catch {
+        return [];
+    }
+}
+/** 从后往前找第一条命中的规则，决定路径是否被忽略。 */
+export function isIgnored(relPath, isDir, rules) {
+    for (let i = rules.length - 1; i >= 0; i -= 1) {
+        const rule = rules[i];
+        if (rule.dirOnly && !isDir) {
+            continue;
+        }
+        if (rule.test(relPath)) {
+            return !rule.negate;
+        }
+    }
+    return false;
+}

package/dist/core/glob.js

@@ -0,0 +1,196 @@
+// ---------------------------------------------------------------------------
+// Glob 匹配
+// 把仓库相对路径（posix 分隔）的 glob 编译成线性时间的匹配函数，分类、分组、
+// 忽略规则共用。约定：独立的 `**` 段跨目录，`*` 不跨目录，`?` 匹配单个非分隔
+// 字符，`{a,b}` 择一；不含 `/` 的模式匹配基准目录下任意层级的同名项，
+// 以 `/` 开头表示从基准目录锚定，以 `/` 结尾表示目录及其全部内容。
+//
+// 匹配按路径分段做记忆化递推，不用回溯正则：`**a` 反复出现的恶意模式
+// （会被一个仓库自带的配置或 .gitignore 带进来）不会让进程卡住。
+// ---------------------------------------------------------------------------
+/** 花括号展开的组合上限，超过就整体按字面量处理，避免配置撑爆内存。 */
+const MAX_ALTERNATIVES = 256;
+const cache = new Map();
+const NEVER = () => false;
+/** 找到与 open 处 `{` 配对的 `}`，考虑嵌套。 */
+function findClose(text, open) {
+    let depth = 0;
+    for (let i = open; i < text.length; i += 1) {
+        if (text[i] === '{') {
+            depth += 1;
+        }
+        else if (text[i] === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+/** 按顶层逗号切分 `{a,{b,c}}` 的内容，嵌套的花括号不切。 */
+function splitAlternatives(body) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < body.length; i += 1) {
+        const ch = body[i];
+        if (ch === '{') {
+            depth += 1;
+        }
+        else if (ch === '}') {
+            depth -= 1;
+        }
+        else if (ch === ',' && depth === 0) {
+            parts.push(body.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(body.slice(start));
+    return parts;
+}
+/** 展开 `{a,b}` 择一写法；没有花括号或展开过多时原样返回。 */
+export function expandBraces(pattern) {
+    const out = [];
+    const walk = (text) => {
+        if (out.length > MAX_ALTERNATIVES) {
+            return;
+        }
+        const open = text.indexOf('{');
+        const close = open === -1 ? -1 : findClose(text, open);
+        if (open === -1 || close === -1) {
+            out.push(text);
+            return;
+        }
+        const head = text.slice(0, open);
+        const tail = text.slice(close + 1);
+        for (const alt of splitAlternatives(text.slice(open + 1, close))) {
+            walk(`${head}${alt}${tail}`);
+        }
+    };
+    walk(pattern);
+    return out.length > MAX_ALTERNATIVES ? [pattern] : out;
+}
+/**
+ * 单个路径段的匹配：`*` 与 `?` 都不跨分隔符（段内本来也没有分隔符）。
+ * 用双指针加单星号回溯，最坏 O(段长 × 模式长)，不会指数爆炸。
+ */
+function matchSegment(pattern, text) {
+    let p = 0;
+    let t = 0;
+    let star = -1;
+    let mark = 0;
+    while (t < text.length) {
+        const ch = pattern[p];
+        if (ch === '*') {
+            star = p;
+            mark = t;
+            p += 1;
+        }
+        else if (ch === '?' || (ch !== undefined && ch === text[t])) {
+            p += 1;
+            t += 1;
+        }
+        else if (star !== -1) {
+            p = star + 1;
+            mark += 1;
+            t = mark;
+        }
+        else {
+            return false;
+        }
+    }
+    while (pattern[p] === '*') {
+        p += 1;
+    }
+    return p === pattern.length;
+}
+/** 逐段匹配，独立的 `**` 段吃掉任意多段路径。 */
+function matchSegments(segments, path) {
+    const parts = path.split('/');
+    const n = segments.length;
+    const m = parts.length;
+    const memo = new Map();
+    const step = (i, j) => {
+        if (i === n) {
+            return j === m;
+        }
+        const key = i * (m + 1) + j;
+        const hit = memo.get(key);
+        if (hit !== undefined) {
+            return hit;
+        }
+        let out;
+        if (segments[i] === '**') {
+            out = step(i + 1, j) || (j < m && step(i, j + 1));
+        }
+        else {
+            out = j < m && matchSegment(segments[i], parts[j]) && step(i + 1, j + 1);
+        }
+        memo.set(key, out);
+        return out;
+    };
+    return step(0, 0);
+}
+/**
+ * 编译一个 glob。base 为模式所锚定的目录（相对仓库根，根目录传空串），
+ * 通常用于 .gitignore：规则里的相对写法都从该文件所在目录起算。
+ */
+export function createGlob(pattern, base = '') {
+    const key = `${base}\u0000${pattern}`;
+    const hit = cache.get(key);
+    if (hit) {
+        return hit;
+    }
+    let body = pattern.startsWith('./') ? pattern.slice(2) : pattern;
+    const anchored = body.startsWith('/');
+    if (anchored) {
+        body = body.slice(1);
+    }
+    const dirOnly = body.endsWith('/');
+    if (dirOnly) {
+        body = body.slice(0, -1);
+    }
+    let matcher = NEVER;
+    if (body !== '') {
+        const baseSegments = base === '' ? [] : base.split('/');
+        // 不含 `/` 的模式可以出现在基准目录下的任意层级
+        const anywhere = !anchored && !body.includes('/');
+        const alternatives = expandBraces(body).map((variant) => {
+            const segments = [...baseSegments];
+            if (anywhere) {
+                segments.push('**');
+            }
+            segments.push(...variant.split('/').filter((seg) => seg !== ''));
+            if (dirOnly) {
+                // 目录本身与它下面的一切都算命中
+                segments.push('**');
+            }
+            return segments;
+        });
+        matcher = (path) => alternatives.some((segments) => matchSegments(segments, path));
+    }
+    cache.set(key, matcher);
+    return matcher;
+}
+/** 路径是否命中任意一个 glob。 */
+export function matchesAny(path, patterns) {
+    return patterns.some((pattern) => createGlob(pattern)(path));
+}
+/**
+ * 取第一个命中 `match` 的 id：按定义顺序，无 `match` 的定义记住、留作兜底，
+ * 全都没有命中时用兜底，再没有就用 fallback。分组与分类的归属都走这一条规则。
+ */
+export function firstMatch(path, defs, fallback) {
+    let empty;
+    for (const def of defs) {
+        if (!def.match || def.match.length === 0) {
+            empty = def.id;
+            continue;
+        }
+        if (matchesAny(path, def.match)) {
+            return def.id;
+        }
+    }
+    return empty ?? fallback;
+}