lostvibe 0.0.0-stage → 0.8.0

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "lostvibe",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.8.0",
+  "description": "프로젝트의 객관 지표를 로컬 로그와 git에서 읽는 CLI. 코드와 대화 내용은 보내지 않는다.",
+  "keywords": [
+    "lostvibe",
+    "vibe-coding",
+    "ai",
+    "metrics",
+    "cli",
+    "claude-code",
+    "codex"
+  ],
+  "homepage": "https://lostvibesociety.com",
+  "type": "module",
+  "bin": {
+    "lostvibe": "bin/lostvibe.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22.15"
+  },
+  "license": "MIT",
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/collectors.mjs

@@ -0,0 +1,198 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { activeConnection, saveJson, selectedProjects, siteOf, request, sendStatus } from './connections.mjs';
+
+export function validateCommand(raw) {
+  if (
+    !Array.isArray(raw) ||
+    !raw.length ||
+    raw.length > 32 ||
+    raw.some((s) => typeof s !== 'string' || !s || s.length > 2000 || s.includes('\0'))
+  )
+    throw new Error('실행 명령을 JSON 문자열 배열로 지정해 주세요.');
+  return raw;
+}
+export function parseCollected(source) {
+  let b;
+  try {
+    b = JSON.parse(source);
+  } catch {
+    throw new Error('수집 명령은 JSON 하나를 출력해야 해요.');
+  }
+  if (!b || typeof b.value !== 'number' || !Number.isFinite(b.value) || b.value < 0 || b.value >= 1e15)
+    throw new Error('성과를 읽지 못했어요. 이전 값을 유지해요.');
+  if (
+    b.date !== undefined &&
+    (!/^\d{4}-\d{2}-\d{2}$/.test(b.date) ||
+      new Date(b.date).toISOString().slice(0, 10) !== b.date ||
+      Date.parse(b.date) > Date.now() + 86400000)
+  )
+    throw new Error('성과 날짜가 맞지 않아요.');
+  const now = new Date();
+  return {
+    value: b.value,
+    date:
+      b.date ||
+      `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`,
+  };
+}
+// A collector cwd is stored relative to the project folder and must stay inside it.
+export function collectorCwd(projectDir, dir) {
+  if (!projectDir) throw new Error('폴더가 없는 프로젝트에는 성과 명령을 연결할 수 없어요.');
+  if (!dir) return '.';
+  let base, target;
+  try {
+    base = fs.realpathSync(projectDir);
+    target = fs.realpathSync(path.resolve(dir));
+  } catch {
+    throw new Error('--cwd 폴더를 찾지 못했어요.');
+  }
+  if (!fs.statSync(target).isDirectory()) throw new Error('--cwd 에는 폴더를 지정해 주세요.');
+  const rel = path.relative(base, target);
+  if (rel.startsWith('..') || path.isAbsolute(rel)) throw new Error('--cwd 는 프로젝트 폴더 안이어야 해요.');
+  return rel || '.';
+}
+const cwdOf = (p, c) => (c.cwd && path.isAbsolute(c.cwd) ? c.cwd : path.join(p.cwd, c.cwd || '.'));
+export function addCollector(o) {
+  if (!['result', 'result2'].includes(o.slot)) throw new Error('--slot result 또는 result2가 필요해요.');
+  let raw;
+  try {
+    raw = JSON.parse(o.commandJson);
+  } catch {
+    throw new Error('--command-json 에 명령 배열이 필요해요.');
+  }
+  const command = validateCommand(raw);
+  const { dir, state, account } = activeConnection(o);
+  const p = Object.values(account?.projects || {}).find((p) => p.id === o.project);
+  if (!p) throw new Error('먼저 이 프로젝트를 setup으로 연결해 주세요.');
+  // Store only an explicitly registered command in user state. Never execute imported/repository config.
+  p.collectors ||= {};
+  p.collectors[o.slot] = { command, cwd: collectorCwd(p.cwd, o.cwd) };
+  saveJson(path.join(dir, 'connections.json'), state);
+}
+export function removeCollector(o) {
+  const { dir, state, account } = activeConnection(o);
+  const p = Object.values(account?.projects || {}).find((p) => p.id === o.project);
+  if (!p || !['result', 'result2'].includes(o.slot)) throw new Error('프로젝트와 성과를 지정해 주세요.');
+  delete p.collectors?.[o.slot];
+  saveJson(path.join(dir, 'connections.json'), state);
+}
+// Failure categories only. stderr and stdout are never printed: they may hold secrets.
+export function classifyFailure({ code, signal, killed, stderr = '' } = {}) {
+  const err = String(stderr);
+  if (code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') return 'JSON 형식 오류';
+  if (killed || signal === 'SIGTERM' || code === 'ETIMEDOUT') return '시간 초과';
+  if (code === 'ENOENT' || /cannot find module|err_module_not_found|modulenotfounderror|no module named|command not found|cannot find package/i.test(err))
+    return '모듈을 찾지 못함';
+  if (/no such table|relation "?[^"\s]*"? does not exist|table '?[^'\s]*'? doesn't exist|undefined_table|42P01|PGRST205|could not find the table/i.test(err))
+    return '테이블 없음';
+  if (/environment variable|env(ironment)? var|\bis not set\b|is not defined in env|missing required env|keyerror: ['"][A-Z][A-Z0-9_]*['"]|process\.env\.[A-Z_]+ is (undefined|missing)|\b[A-Z][A-Z0-9]*_(URL|KEY|TOKEN|SECRET|DSN)\b.*(missing|required|undefined|not (set|found|defined))/i.test(err))
+    return '환경 변수 없음';
+  if (/ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ECONNRESET|ETIMEDOUT|getaddrinfo|could not connect|connection (refused|terminated|failed|error)|password authentication failed|authentication failed|too many connections|SQLITE_CANTOPEN|unable to open database|database .* does not exist|fetch failed|server closed the connection/i.test(err))
+    return 'DB 연결 실패';
+  return '알 수 없는 오류';
+}
+class CollectorError extends Error {
+  constructor(kind) {
+    super(`성과 조회 명령이 실패했어요 (${kind}). 이전 값을 유지해요.`);
+    this.kind = kind;
+  }
+}
+async function run(command, cwd) {
+  const env = { ...process.env };
+  for (const k of ['LOSTVIBE_TOKEN', 'LOSTVIBE_METRICS_TOKEN']) delete env[k];
+  return new Promise((resolve, reject) =>
+    execFile(
+      command[0],
+      command.slice(1),
+      { cwd, env, timeout: 20000, maxBuffer: 64_000, windowsHide: true },
+      (e, stdout, stderr) =>
+        e
+          ? reject(new CollectorError(classifyFailure({ code: e.code, signal: e.signal, killed: e.killed, stderr })))
+          : resolve(stdout),
+    ),
+  );
+}
+// Runs a collector the way collect does and returns { value, date } or throws with .kind.
+export async function runCollector(command, cwd) {
+  const out = await run(validateCommand(command), cwd);
+  try {
+    return parseCollected(out);
+  } catch {
+    throw new CollectorError('JSON 형식 오류');
+  }
+}
+export async function testCollector(o) {
+  let raw;
+  try {
+    raw = JSON.parse(o.commandJson);
+  } catch {
+    throw new Error('--command-json 에 명령 배열이 필요해요.');
+  }
+  const command = validateCommand(raw);
+  const p = o.project ? selectedProjects(o).find((x) => x.id === o.project) : null;
+  if (o.project && !p) throw new Error('먼저 이 프로젝트를 setup으로 연결해 주세요.');
+  const base = p?.cwd || process.cwd();
+  const cwd = o.cwd ? path.join(base, collectorCwd(base, o.cwd)) : base;
+  try {
+    const sample = await runCollector(command, cwd);
+    console.log(`값: ${sample.value} (${sample.date})`);
+  } catch (e) {
+    console.error(`실패: ${e.kind || '알 수 없는 오류'}`);
+    process.exitCode = 1;
+  }
+}
+export async function collect(o, token) {
+  const site = siteOf(o),
+    { dir } = activeConnection(o);
+  const selected = selectedProjects(o);
+  if (!selected.length) return;
+  const connection = await request(site, token, '/api/me/connection');
+  const ids = new Set(connection.projects.map((p) => p.id));
+  const skipped = new Set((connection.skipped || []).map((p) => p.sourceId));
+  let failed = 0;
+  for (const p of selected.filter((p) => ids.has(p.id) && !skipped.has(p.sourceId))) {
+    if (!p.cwd || !Object.keys(p.collectors || {}).length) continue;
+    const current = await request(site, token, `/api/projects/${p.id}`);
+    for (const [slot, c] of Object.entries(p.collectors || {})) {
+      if (!current[slot]?.name) continue;
+      const lock = path.join(dir, `collector-${p.id}-${slot}.lock`);
+      try {
+        const old = Number(fs.readFileSync(lock, 'utf8'));
+        try {
+          process.kill(old, 0);
+          continue;
+        } catch {
+          fs.rmSync(lock, { force: true });
+        }
+      } catch {
+        /* no active lock */
+      }
+      try {
+        fs.writeFileSync(lock, String(process.pid), { flag: 'wx', mode: 0o600 });
+      } catch {
+        continue;
+      }
+      try {
+        const sample = await runCollector(c.command, cwdOf(p, c));
+        const tokenFile = path.join(p.cwd, '.lostvibe', `metrics-token-${p.id}`);
+        const scoped = fs.readFileSync(tokenFile, 'utf8').trim();
+        const result = await request(site, scoped, `/api/me/projects/${p.id}/metrics`, 'POST', {
+          metrics: [{ slot, ...sample }],
+        });
+        if (!result.saved || result.refused?.length)
+          throw new Error('성과가 연결되어 있지 않거나 제외됐어요.');
+        await sendStatus(site, scoped, p.id, slot, true);
+        if (!o.quiet) console.log(`${p.name} · ${slot}: ${sample.value} (${sample.date})`);
+      } catch (e) {
+        failed++;
+        await sendStatus(site, token, p.id, slot, false);
+        if (!o.quiet) console.error(`${p.name} · ${slot}: ${e.message}`);
+      } finally {
+        fs.rmSync(lock, { force: true });
+      }
+    }
+  }
+  if (failed) throw new Error(`성과 ${failed}개를 갱신하지 못했어요. 이전 값은 유지했어요.`);
+}

package/src/connections.mjs

@@ -0,0 +1,142 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { resolveCwd, projectIdentity, sha } from './gitinfo.mjs';
+export const VERSION = '0.8.0';
+export const stateDir = (o = {}) =>
+  path.resolve(o.out || process.env.LOSTVIBE_DIR || path.join(os.homedir(), '.lostvibe'));
+export function readState(dir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(dir, 'connections.json'), 'utf8'));
+  } catch {
+    return { accounts: {} };
+  }
+}
+export function saveJson(file, data) {
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+  fs.renameSync(tmp, file);
+}
+export function activeConnection(o = {}) {
+  const dir = stateDir(o),
+    state = readState(dir);
+  const account = state.accounts?.[state.active];
+  return { dir, state, account };
+}
+// A folder without git is the project `folder:<name>`, the same key scan --all gives it.
+export function currentIdentity(cwd = process.cwd()) {
+  const r = resolveCwd(cwd);
+  if (r.repoPath) return { ...r, cwd: r.repoPath, sourceId: projectIdentity(r.repoPath, r.key) };
+  if (cwd === os.homedir() || cwd === path.dirname(cwd)) throw new Error('프로젝트 폴더 안에서 실행해 주세요.');
+  return { ...r, cwd, sourceId: projectIdentity(null, r.key) };
+}
+export function siteOf(o = {}) {
+  const { account } = activeConnection(o);
+  const site = (
+    o.site ||
+    process.env.LOSTVIBE_SITE ||
+    account?.site ||
+    'https://lostvibesociety.com'
+  ).replace(/\/$/, '');
+  const u = new URL(site);
+  if (
+    u.username ||
+    u.password ||
+    !['https:', 'http:'].includes(u.protocol) ||
+    (u.protocol === 'http:' && !['localhost', '127.0.0.1', '[::1]'].includes(u.hostname))
+  )
+    throw new Error('HTTPS 사이트 주소가 필요해요.');
+  return site;
+}
+export async function request(site, token, url, method = 'GET', body) {
+  let res;
+  for (let i = 0; ; i++) {
+    res = await fetch(site + url, {
+      method,
+      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: AbortSignal.timeout(30000),
+    });
+    if (res.status !== 429 || i >= 3) break;
+    await new Promise((r) =>
+      setTimeout(r, Math.min(5, Math.max(1, Number(res.headers.get('retry-after')) || 2)) * 1000),
+    );
+  }
+  const d = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(`Lostvibe 요청 실패 (${res.status}). 키와 응답 본문은 출력하지 않았어요.`);
+  return d;
+}
+export async function registerCurrent(o, token) {
+  const current = currentIdentity();
+  return registerProject(o, token, { sourceId: current.sourceId, name: current.name, cwd: current.cwd });
+}
+// ident: { sourceId, name, cwd (null for a project known only from logs), roots? }
+export async function registerProject(o, token, current) {
+  const dir = stateDir(o),
+    site = siteOf(o),
+    connection = await request(site, token, '/api/me/connection');
+  const existing = connection.projects.find((p) => p.sourceId === current.sourceId);
+  if (o.project && (!existing || existing.id !== o.project))
+    throw new Error('선택한 프로젝트와 현재 폴더가 달라요. 올바른 폴더에서 다시 실행해 주세요.');
+  if (connection.skipped?.some((p) => p.sourceId === current.sourceId))
+    throw new Error('넘긴 프로젝트예요. 사이트에서 다시 가져온 뒤 연결해 주세요.');
+  const target =
+    existing ||
+    (await request(site, token, '/api/me/projects', 'POST', {
+      name: current.name,
+      sourceId: current.sourceId,
+    }));
+  const state = readState(dir);
+  const key = sha(`${site}:${connection.login}`);
+  state.accounts ||= {};
+  state.accounts[key] ||= { site, login: connection.login, projects: {} };
+  const account = state.accounts[key];
+  const prev = account.projects[current.sourceId] || {};
+  const roots = [...new Set([...(prev.roots || []), ...(current.roots || [])])];
+  account.projects[current.sourceId] = {
+    ...prev,
+    sourceId: current.sourceId,
+    id: target.id,
+    cwd: current.cwd || null,
+    name: current.name,
+    ...(roots.length ? { roots } : {}),
+  };
+  state.active = key;
+  saveJson(path.join(dir, 'connections.json'), state);
+  return account.projects[current.sourceId];
+}
+// Other scan ids whose logs count as this project's. roots are workspaces that place their folders.
+export function setMerge(o, sourceId, ids, roots = []) {
+  const { dir, state, account } = activeConnection(o);
+  const p = account?.projects?.[sourceId];
+  if (!p) throw new Error('먼저 이 프로젝트를 setup으로 연결해 주세요.');
+  p.merge = [...new Set([...(p.merge || []), ...ids])].filter((id) => id !== sourceId);
+  const all = [...new Set([...(p.roots || []), ...roots])];
+  if (all.length) p.roots = all;
+  saveJson(path.join(dir, 'connections.json'), state);
+  return p;
+}
+// other sourceId -> main sourceId, for scanAll({ merge }).
+export function mergeMap(projects) {
+  const map = new Map();
+  for (const p of projects) for (const id of p.merge || []) if (id !== p.sourceId) map.set(id, p.sourceId);
+  return map;
+}
+export function selectedProjects(o = {}) {
+  const { account } = activeConnection(o);
+  if (!account) return [];
+  const selected = o.only ? new Set(o.only.split(',').map((x) => x.trim())) : null;
+  return Object.values(account.projects).filter(
+    (p) =>
+      (!o.project || p.id === o.project) &&
+      (!selected || selected.has(p.id) || selected.has(p.sourceId) || selected.has(p.name)),
+  );
+}
+export async function sendStatus(site, token, id, kind, ok) {
+  try {
+    await request(site, token, `/api/me/projects/${id}/sync-status`, 'POST', { kind, ok });
+  } catch {
+    /* A status report must not hide the original result. */
+  }
+}

package/src/gitinfo.mjs

@@ -0,0 +1,176 @@
+import { execFileSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { localDate } from './logs.mjs';
+
+function git(dir, args) {
+  return execFileSync('git', ['-C', dir, ...args], {
+    encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 1024 * 1024 * 256, timeout: 120000,
+  }).trim();
+}
+
+export function sha(s) {
+  return crypto.createHash('sha256').update(s).digest('hex').slice(0, 32);
+}
+
+export function normalizeRemote(url) {
+  if (!url) return null;
+  let u = url.trim().replace(/\/+$/, '').replace(/\.git$/, '');
+  const ssh = u.match(/^git@([^:]+):(.+)$/);
+  if (ssh) u = `${ssh[1]}/${ssh[2]}`;
+  u = u.replace(/^[a-z+]+:\/\//, '').replace(/^[^@/]+@/, '').replace(/:22\//, '/');
+  return u.toLowerCase();
+}
+
+function nearestExisting(p) {
+  let cur = p;
+  while (cur && cur !== path.dirname(cur)) {
+    try { if (fs.statSync(cur).isDirectory()) return cur; } catch { /* keep walking */ }
+    cur = path.dirname(cur);
+  }
+  return null;
+}
+
+const cache = new Map();
+
+// The oldest commit is the same on every computer, and reading it writes nothing into the repo.
+export function rootCommit(repo) {
+  try {
+    const roots = git(repo, ['rev-list', '--max-parents=0', '--branches', '--tags', '--remotes']).split('\n').filter(Boolean).sort();
+    return roots[0] || null;
+  } catch { return null; }
+}
+
+// A remote names the project, so two forks of one template stay two projects.
+// Without a remote the first commit does, so copies on two computers still join.
+export function projectIdentity(repo, key) {
+  if (!repo || key.startsWith('remote:')) return sha(key);
+  const root = rootCommit(repo);
+  return root ? sha(`root:${root}`) : sha(key);
+}
+
+// Other names this project may already be known by. Earlier CLI versions saved one in git config.
+export function projectAliases(repo, key) {
+  const out = [sha(key)];
+  if (repo) {
+    try {
+      const saved = git(repo, ['config', '--local', '--get', 'lostvibe.project-id']);
+      if (/^[a-f0-9]{32}$/.test(saved)) out.push(saved);
+    } catch { /* nothing saved */ }
+  }
+  return out;
+}
+
+
+// A working directory resolves to one project: the main repo for worktrees and subfolders,
+// keyed by git remote so the same repo at two paths is one project.
+export function resolveCwd(cwd) {
+  if (cache.has(cwd)) return cache.get(cwd);
+  const res = resolveUncached(cwd);
+  cache.set(cwd, res);
+  return res;
+}
+
+function resolveUncached(cwd) {
+  const dir = nearestExisting(cwd);
+  let root = null;
+  if (dir) {
+    try {
+      const top = git(dir, ['rev-parse', '--show-toplevel']);
+      let common = git(dir, ['rev-parse', '--git-common-dir']);
+      if (!path.isAbsolute(common)) common = path.resolve(dir, common);
+      root = path.basename(common) === '.git' ? path.dirname(common) : top;
+    } catch { /* not a repo */ }
+  }
+  if (root) {
+    let remote = null;
+    try { remote = normalizeRemote(git(root, ['remote', 'get-url', 'origin'])); } catch { /* no remote */ }
+    return { key: remote ? `remote:${remote}` : `path:${root}`, repoPath: root, remote, name: path.basename(root) };
+  }
+  return { key: `folder:${path.basename(cwd).toLowerCase()}`, repoPath: null, remote: null, name: path.basename(cwd), exists: dir === cwd };
+}
+
+export function commitCount(repo) {
+  try { return Number(git(repo, ['rev-list', '--count', '--branches', '--tags', '--remotes', '--no-merges'])) || 0; } catch { return 0; }
+}
+
+export function gitMetrics(repo) {
+  let out = '';
+  try {
+    out = git(repo, ['log', '--branches', '--tags', '--remotes', '--no-merges', '--format=%aI%x09%ae']);
+  } catch { /* empty repo */ }
+  const daily = new Map();
+  const people = new Set();
+  let commits = 0;
+  for (const line of out.split('\n')) {
+    if (!line) continue;
+    const [timestamp, email] = line.split('\t');
+    const parsed = new Date(timestamp);
+    if (Number.isNaN(parsed.getTime())) continue;
+    const date = localDate(parsed);
+    commits++;
+    daily.set(date, (daily.get(date) || 0) + 1);
+    if (email && !email.includes('[bot]')) people.add(email.toLowerCase());
+  }
+  const dates = [...daily.keys()].sort();
+  const first = dates[0] || null;
+  const last = dates[dates.length - 1] || null;
+  const days = first ? Math.round((Date.parse(last) - Date.parse(first)) / 86400000) + 1 : 0;
+  return {
+    commits, first_commit: first, last_commit: last, days_alive: days, contributors: people.size,
+    daily_commits: dates.map((date) => ({ date, n: daily.get(date) })),
+  };
+}
+
+const EXCLUDE_DIR = /(^|\/)(node_modules|dist|build|out|\.next|\.nuxt|\.vercel|\.turbo|\.cache|coverage|vendor|Pods|DerivedData|__pycache__|\.venv|venv|target|\.gradle)(\/|$)/;
+const EXCLUDE_FILE = /(^|\/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb?|Cargo\.lock|Gemfile\.lock|Podfile\.lock|poetry\.lock|composer\.lock|go\.sum|uv\.lock|Package\.resolved)$|\.min\.(js|css)$|\.map$/;
+const BINARY = /\.(png|jpe?g|gif|webp|avif|ico|icns|svg|pdf|zip|gz|tar|tgz|rar|7z|mp3|mp4|mov|wav|m4a|webm|woff2?|ttf|otf|eot|heic|psd|ai|sketch|fig|bin|exe|dll|so|dylib|a|o|class|jar|wasm|sqlite3?|db|xcassets|car|p12|mobileprovision)$/i;
+
+// Data and documents are counted separately so a 900k-line JSON catalog does not read as code.
+const NON_CODE = new Set(['JSON', 'CSV', 'Text', 'Markdown', 'XML', 'YAML', 'TOML', 'Other']);
+
+const LANGS = {
+  ts: 'TypeScript', tsx: 'TypeScript', mts: 'TypeScript', cts: 'TypeScript', js: 'JavaScript', jsx: 'JavaScript', mjs: 'JavaScript', cjs: 'JavaScript',
+  py: 'Python', swift: 'Swift', kt: 'Kotlin', java: 'Java', go: 'Go', rs: 'Rust', rb: 'Ruby', php: 'PHP', c: 'C', h: 'C', cpp: 'C++', cc: 'C++', hpp: 'C++', m: 'Objective-C', mm: 'Objective-C', cs: 'C#', dart: 'Dart', vue: 'Vue', svelte: 'Svelte',
+  html: 'HTML', css: 'CSS', scss: 'CSS', sql: 'SQL', sh: 'Shell', bash: 'Shell', zsh: 'Shell', prisma: 'Prisma', md: 'Markdown', mdx: 'Markdown', json: 'JSON', yaml: 'YAML', yml: 'YAML', toml: 'TOML', csv: 'CSV', tsv: 'CSV', txt: 'Text', xml: 'XML', plist: 'XML', graphql: 'GraphQL',
+};
+
+export function codeMetrics(repo) {
+  let list;
+  try {
+    list = execFileSync('git', ['-C', repo, 'ls-files', '-z'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 1024 * 1024 * 256 }).split('\0').filter(Boolean);
+  } catch { return null; }
+  let lines = 0;
+  let nonCode = 0;
+  let files = 0;
+  const byLang = new Map();
+  for (const rel of list) {
+    if (EXCLUDE_DIR.test(rel) || EXCLUDE_FILE.test(rel) || BINARY.test(rel)) continue;
+    let buf;
+    try {
+      const st = fs.statSync(path.join(repo, rel));
+      if (!st.isFile()) continue;
+      buf = fs.readFileSync(path.join(repo, rel));
+    } catch { continue; }
+    if (buf.subarray(0, 8192).includes(0)) continue;
+    let n = 0;
+    for (let i = 0; i < buf.length; i++) if (buf[i] === 10) n++;
+    if (buf.length && buf[buf.length - 1] !== 10) n++;
+    files++;
+    const ext = path.extname(rel).slice(1).toLowerCase();
+    const lang = LANGS[ext] || 'Other';
+    if (NON_CODE.has(lang)) { nonCode += n; continue; }
+    lines += n;
+    byLang.set(lang, (byLang.get(lang) || 0) + n);
+  }
+  return {
+    lines, files, non_code_lines: nonCode,
+    languages: [...byLang.entries()].sort((a, b) => b[1] - a[1]).map(([name, n]) => ({ name, lines: n })),
+  };
+}
+
+export function githubSlug(remote) {
+  const m = remote && remote.match(/^github\.com\/([^/]+)\/([^/]+)$/);
+  return m ? { owner: m[1], repo: m[2] } : { owner: '', repo: '' };
+}