lostvibe 0.0.0-stage → 0.7.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.7.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,129 @@
+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')}`,
+  };
+}
+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: p.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);
+}
+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) =>
+        e ? reject(new Error('성과 조회 명령이 실패했어요. 이전 값을 유지해요.')) : resolve(stdout),
+    ),
+  );
+}
+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 (!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 = parseCollected(await run(validateCommand(c.command), c.cwd));
+        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,116 @@
+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.7.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 };
+}
+export function currentIdentity() {
+  const r = resolveCwd(process.cwd());
+  if (!r.repoPath) throw new Error('프로젝트의 git 폴더에서 실행해 주세요.');
+  return { ...r, sourceId: projectIdentity(r.repoPath, 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 dir = stateDir(o),
+    site = siteOf(o),
+    connection = await request(site, token, '/api/me/connection');
+  const current = currentIdentity();
+  const existing = connection.projects.find((p) => p.sourceId === current.sourceId);
+  if (o.project && (!existing || existing.id !== o.project))
+    throw new Error('선택한 프로젝트와 현재 git 폴더가 달라요. 올바른 폴더에서 다시 실행해 주세요.');
+  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];
+  account.projects[current.sourceId] = {
+    ...account.projects[current.sourceId],
+    sourceId: current.sourceId,
+    id: target.id,
+    cwd: current.repoPath,
+    name: current.name,
+  };
+  state.active = key;
+  saveJson(path.join(dir, 'connections.json'), state);
+  return account.projects[current.sourceId];
+}
+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: '' };
+}

package/src/hooks.mjs

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { VERSION, stateDir, saveJson } from './connections.mjs';
+const quote = (s) => `'${s.replace(/'/g, "'\\''")}'`;
+function load(file, fallback = {}) {
+  if (!fs.existsSync(file)) return fallback;
+  const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (!data || typeof data !== 'object' || Array.isArray(data))
+    throw new Error(`설정 형식을 읽지 못했어요: ${path.basename(file)}`);
+  return data;
+}
+function targets() {
+  const list = [];
+  const claude = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  const codex = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  if (fs.existsSync(claude))
+    list.push({ client: 'Claude Code', file: path.join(claude, 'settings.json'), event: 'SessionEnd' });
+  if (fs.existsSync(codex))
+    for (const event of ['Stop', 'SessionEnd'])
+      list.push({ client: 'Codex', file: path.join(codex, 'hooks.json'), event });
+  return list;
+}
+function ownGroups(config, event, command, remove = false) {
+  config.hooks ||= {};
+  const groups = config.hooks[event] || [];
+  if (!Array.isArray(groups)) throw new Error('기존 훅 형식을 읽지 못했어요. 변경하지 않았어요.');
+  if (remove) {
+    config.hooks[event] = groups
+      .map((g) => ({ ...g, hooks: (g.hooks || []).filter((h) => h.command !== command) }))
+      .filter((g) => g.hooks.length);
+    if (!config.hooks[event].length) delete config.hooks[event];
+  } else if (!groups.some((g) => g.hooks?.some((h) => h.command === command))) {
+    config.hooks[event] = [...groups, { hooks: [{ type: 'command', command, timeout: 10 }] }];
+  }
+  return config;
+}
+export function installHooks(o) {
+  const dir = stateDir(o),
+    chosen = targets().filter((t) => !o.client || t.client.toLowerCase().startsWith(o.client.toLowerCase()));
+  if (!chosen.length) throw new Error('연결할 Claude Code 또는 Codex 설정 폴더를 찾지 못했어요.');
+  const packageRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+  const runtime = path.join(dir, 'runtime', VERSION);
+  fs.mkdirSync(runtime, { recursive: true });
+  for (const part of ['src', 'bin'])
+    if (path.resolve(packageRoot) !== path.resolve(runtime))
+      fs.cpSync(path.join(packageRoot, part), path.join(runtime, part), { recursive: true });
+  const command = `${quote(process.execPath)} ${quote(path.join(runtime, 'bin', 'lostvibe.mjs'))} hook --out ${quote(dir)}`;
+  const registryFile = path.join(dir, 'hooks.json');
+  const registry = load(registryFile, { entries: [] });
+  // Validate all files before changing any. Keep other hooks and notify untouched.
+  const configs = new Map();
+  for (const t of chosen) if (!configs.has(t.file)) configs.set(t.file, load(t.file));
+  for (const t of chosen) {
+    const config = configs.get(t.file);
+    for (const old of registry.entries.filter((e) => e.file === t.file && e.event === t.event))
+      ownGroups(config, t.event, old.command, true);
+    ownGroups(config, t.event, command);
+  }
+  for (const [file, config] of configs) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    if (fs.existsSync(file) && !fs.existsSync(file + '.lostvibe-backup'))
+      fs.copyFileSync(file, file + '.lostvibe-backup');
+    saveJson(file, config);
+  }
+  registry.entries = [
+    ...registry.entries.filter((e) => !chosen.some((t) => t.file === e.file && t.event === e.event)),
+    ...chosen.map((t) => ({ ...t, command })),
+  ];
+  saveJson(registryFile, registry);
+  return [...new Set(chosen.map((t) => t.client))];
+}
+export function removeHooks(o) {
+  const file = path.join(stateDir(o), 'hooks.json');
+  const registry = load(file, { entries: [] });
+  const keep = [];
+  for (const e of registry.entries) {
+    if (o.client && !e.client.toLowerCase().startsWith(o.client.toLowerCase())) {
+      keep.push(e);
+      continue;
+    }
+    if (fs.existsSync(e.file)) {
+      const c = load(e.file);
+      saveJson(e.file, ownGroups(c, e.event, e.command, true));
+    }
+  }
+  registry.entries = keep;
+  saveJson(file, registry);
+}
+export function hookStatus(o) {
+  const registry = load(path.join(stateDir(o), 'hooks.json'), { entries: [] });
+  return registry.entries.map((e) => ({
+    ...e,
+    installed:
+      load(e.file).hooks?.[e.event]?.some((g) => g.hooks?.some((h) => h.command === e.command)) || false,
+  }));
+}