@sejuneoh/aitop 0.0.0-stage → 0.21.2

package/src/pricing.mjs

@@ -0,0 +1,130 @@
+// Claude API 정가 기준 환산 비용 (USD / 100만 토큰). 구독 요금제 사용분도 "API 로 썼다면" 기준으로 계산한다.
+// 출처: Anthropic 모델 가격표(2026-10). 캐시 읽기는 입력가의 0.1배, 캐시 쓰기는 5분 1.25배·1시간 2배.
+import { createHash } from 'node:crypto';
+
+const PRICES = {
+  'claude-fable-5-1': { input: 10, output: 50, cacheRead: 0.25 },
+  'claude-mythos-5-1': { input: 10, output: 50, cacheRead: 0.25 },
+  'claude-fable-5': { input: 10, output: 50 },
+  'claude-opus-5-5': { input: 4, output: 20, cacheRead: 0.2, fast: 2 },
+  'claude-opus-5': { input: 5, output: 25, fast: 2 },
+  'claude-opus-4-8': { input: 5, output: 25, fast: 2 },
+  'claude-opus-4-7': { input: 5, output: 25 },
+  'claude-opus-4-6': { input: 5, output: 25 },
+  'claude-sonnet-5-5': { input: 2, output: 10, cacheRead: 0.2 },
+  'claude-sonnet-5': { input: 2, output: 10 },
+  'claude-sonnet-4-6': { input: 3, output: 15 },
+  'claude-haiku-5-5': { input: 0.1, output: 0.5 },
+  'claude-haiku-4-5': { input: 1, output: 5 },
+};
+
+// Gemini API 정가 (USD / 100만 토큰, 유료 등급 standard). Antigravity CLI(agy) 사용분을 "API 로 썼다면" 기준으로 계산한다.
+// 출처: Google 공식 가격표 https://aistudio.google.com/docs/pricing (2026-11-06 확인). 긴 컨텍스트 구간은 따로 없다.
+// 출력에는 생각 토큰이 들어 있고, cacheRead 는 context caching 가격이다. 가격이 바뀌는 모델은 날짜순 목록이며,
+// from 은 그 가격이 시작되는 날(UTC 0시)이다.
+const GEMINI_PRICES = {
+  'gemini-4-argon': [
+    { input: 2, output: 10, cacheRead: 0.1 },
+    { from: '2026-12-01', input: 4, output: 20, cacheRead: 0.2 },
+  ],
+  'gemini-3.8-flash': [
+    { input: 0.75, output: 3.75, cacheRead: 0.075 },
+    { from: '2027-01-01', input: 1.5, output: 7.5, cacheRead: 0.15 },
+  ],
+  'gemini-3.6-flash': [
+    { input: 0.75, output: 3.75, cacheRead: 0.075 },
+    { from: '2027-01-01', input: 1.5, output: 7.5, cacheRead: 0.15 },
+  ],
+  'gemini-3.5-flash-lite': [{ input: 0.3, output: 2.5, cacheRead: 0.03 }],
+  'gemini-3.1-flash-lite': [{ input: 0.25, output: 1.5, cacheRead: 0.025 }],
+};
+
+// 가격표가 바뀌면 이 값이 바뀌고, 캐시 폴더도 바뀌어 예전 비용이 다시 계산된다.
+export const PRICE_TAG = createHash('sha1').update(JSON.stringify([PRICES, GEMINI_PRICES])).digest('hex').slice(0, 8);
+
+// 모델별 컨텍스트 창 크기(토큰). 출처: Anthropic 모델 표(2026-10). 표에 없는 모델은 contextWindow 가 추측한다.
+const WINDOWS = {
+  // Gemini 계열의 입력 한도(1,048,576 토큰). Antigravity 의 내부 모델 이름(gemini-4-argon 등)도 같다고 본다.
+  'gemini-': 1_048_576,
+  'claude-fable-5-1': 1_000_000,
+  'claude-mythos-5-1': 1_000_000,
+  'claude-fable-5': 1_000_000,
+  'claude-opus-5-5': 1_000_000,
+  'claude-opus-5': 1_000_000,
+  'claude-opus-4-8': 1_000_000,
+  'claude-opus-4-7': 1_000_000,
+  'claude-opus-4-6': 1_000_000,
+  'claude-sonnet-5-5': 1_000_000,
+  'claude-sonnet-5': 1_000_000,
+  'claude-sonnet-4-6': 1_000_000,
+  'claude-haiku-5-5': 1_000_000,
+  'claude-haiku-4-5': 200_000,
+};
+
+function lookup(table, model) {
+  if (!model) return null;
+  if (table[model]) return table[model];
+  const key = Object.keys(table)
+    .sort((a, b) => b.length - a.length)
+    .find((k) => model.startsWith(k));
+  return key ? table[key] : null;
+}
+
+// 모르는 모델은 사용량으로 추측한다: 200k 를 넘었으면 1M 창, 아니면 200k 창.
+export function contextWindow(model, used = 0) {
+  return lookup(WINDOWS, model) ?? (used > 200_000 ? 1_000_000 : 200_000);
+}
+
+function priceOf(model) {
+  return lookup(PRICES, model);
+}
+
+// Claude 메시지 usage 한 건의 환산 비용. total 은 캐시 포함, noCache 는 입력·출력만. 가격표에 없는 모델이면 null.
+export function claudeCost(model, u) {
+  const p = priceOf(model);
+  if (!p || !u) return null;
+  const m = u.speed === 'fast' && p.fast ? p.fast : 1;
+  const input = p.input * m;
+  const write1h = u.cache_creation?.ephemeral_1h_input_tokens ?? 0;
+  const write5m = u.cache_creation ? (u.cache_creation.ephemeral_5m_input_tokens ?? 0) : (u.cache_creation_input_tokens ?? 0);
+  const base = (u.input_tokens ?? 0) * input + (u.output_tokens ?? 0) * p.output * m;
+  const cache = (u.cache_read_input_tokens ?? 0) * (p.cacheRead ?? p.input * 0.1) * m + write5m * input * 1.25 + write1h * input * 2;
+  return { total: (base + cache) / 1e6, noCache: base / 1e6 };
+}
+
+// Codex(OpenAI) API 정가 기준 환산 비용 (USD / 100만 토큰). Claude 와 같이 "API 로 썼다면" 기준이다.
+// 출처: 2026-11 가격 비교 사이트(pricepertoken.com, computeprices.com)의 OpenAI 정가. 추정값이라 README 에 적어 둔다.
+const OPENAI_PRICES = {
+  'gpt-5.3-codex': { input: 1.75, cacheRead: 0.175, output: 14 },
+  'gpt-5.1-codex-mini': { input: 0.25, cacheRead: 0.025, output: 2 },
+  'gpt-5.1-codex': { input: 1.25, cacheRead: 0.125, output: 10 },
+  'codex-mini': { input: 1.5, cacheRead: 0.375, output: 6 },
+  'gpt-4o-mini': { input: 0.15, cacheRead: 0.075, output: 0.6 },
+};
+
+// Codex 세션 누적 토큰(tokens: input 은 캐시 제외, cacheRead, output)의 환산 비용. 가격표에 없는 모델이면 null.
+export function codexCost(model, t) {
+  const p = lookup(OPENAI_PRICES, model);
+  if (!p || !t) return null;
+  const base = (t.input ?? 0) * p.input + (t.output ?? 0) * p.output;
+  return { total: (base + (t.cacheRead ?? 0) * p.cacheRead) / 1e6, noCache: base / 1e6 };
+}
+
+// 시각 at(ms)에 쓰던 Gemini 가격. 모델 이름이 표와 똑같을 때만 찾는다:
+// 앞부분만 같은 다른 모델(gemini-3.8-flash-lite 와 gemini-3.8-flash 등)에 엉뚱한 가격을 매기지 않기 위해서다.
+export function geminiPrice(model, at = Date.now()) {
+  const list = model ? GEMINI_PRICES[model] : null;
+  if (!list) return null;
+  let p = list[0];
+  for (const x of list) if (x.from && at >= Date.parse(x.from)) p = x;
+  return p;
+}
+
+// agy 호출 한 번(t: input 은 캐시 제외, cacheRead, output 은 생각 포함)을 at 시각의 가격으로 환산한다. 가격표에 없는 모델이면 null.
+// agy 는 암시적 캐시만 써서 캐시 쓰기 요금이 없다.
+export function geminiCost(model, t, at) {
+  const p = geminiPrice(model, at);
+  if (!p || !t) return null;
+  const base = (t.input ?? 0) * p.input + (t.output ?? 0) * p.output;
+  return { total: (base + (t.cacheRead ?? 0) * p.cacheRead) / 1e6, noCache: base / 1e6 };
+}

package/src/procs.mjs

@@ -0,0 +1,205 @@
+// 실행 중인 AI CLI 프로세스와 그 작업 폴더를 찾는다.
+// Linux·WSL 은 /proc 를 읽고, macOS 는 ps 와 lsof 를 부른다. 그 밖의 OS 는 프로세스를 세지 못한다.
+import { readdirSync, readFileSync, readlinkSync, existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { platform } from 'node:os';
+
+const OS = platform();
+const HAS_PROC = existsSync('/proc/self');
+
+export function canListProcesses() {
+  return HAS_PROC || OS === 'darwin';
+}
+
+// 신호 0 은 보내지 않고 프로세스가 있는지만 본다. 다른 사용자 프로세스면 EPERM 이지만 살아 있다.
+export function isAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === 'EPERM';
+  }
+}
+
+// ps 는 인자를 공백으로만 이어 보여 준다. 앞 두 칸(실행 파일, node 스크립트)이 없는 절대 경로면
+// 실제로 있는 경로가 될 때까지 뒤 토큰을 이어 붙인다 (예: ~/Library/Application Support/…/codex.js).
+export function joinPaths(tokens, exists = existsSync) {
+  const out = [];
+  let i = 0;
+  while (i < tokens.length) {
+    let cur = tokens[i++];
+    if (out.length < 2 && cur.startsWith('/') && !exists(cur)) {
+      let j = i;
+      let joined = cur;
+      while (j < tokens.length && j - i < 8) {
+        joined += ' ' + tokens[j++];
+        if (exists(joined)) {
+          cur = joined;
+          i = j;
+          break;
+        }
+      }
+    }
+    out.push(cur);
+  }
+  return out;
+}
+
+// ps -axo pid=,command= 출력을 { pid, argv } 목록으로.
+export function parsePs(text, exists = existsSync) {
+  const out = [];
+  for (const line of String(text).split('\n')) {
+    const m = /^\s*(\d+)\s+(.+)$/.exec(line);
+    if (m) out.push({ pid: Number(m[1]), argv: joinPaths(m[2].trim().split(/\s+/), exists) });
+  }
+  return out;
+}
+
+// lsof -a -p PID -d cwd -Fn 출력에서 n 으로 시작하는 줄이 작업 폴더다.
+export function parseLsofCwd(text) {
+  return /^n(.+)$/m.exec(String(text))?.[1] ?? null;
+}
+
+const run = (cmd, args, env) => execFileSync(cmd, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000, env });
+
+function listProc() {
+  const list = [];
+  let pids = [];
+  try {
+    pids = readdirSync('/proc').filter((n) => /^\d+$/.test(n));
+  } catch {}
+  for (const pid of pids) {
+    let argv;
+    try {
+      argv = readFileSync(`/proc/${pid}/cmdline`, 'utf8').split('\0').filter(Boolean);
+    } catch {
+      continue;
+    }
+    if (argv.length) list.push({ pid: Number(pid), argv });
+  }
+  return list;
+}
+
+function listPs() {
+  try {
+    return parsePs(run('ps', ['-axww', '-o', 'pid=,command=']));
+  } catch {
+    return [];
+  }
+}
+
+// 한 번의 갱신 안에서 여러 도구가 각각 훑지 않도록 결과를 재사용한다. ps 는 프로세스를 띄우므로 더 길게 둔다.
+const SCAN_TTL_MS = HAS_PROC ? 500 : 2000;
+let scan = { at: 0, list: [] };
+
+function scanAll() {
+  if (Date.now() - scan.at < SCAN_TTL_MS) return scan.list;
+  const list = (HAS_PROC ? listProc() : OS === 'darwin' ? listPs() : []).filter((p) => p.pid !== process.pid);
+  scan = { at: Date.now(), list };
+  return list;
+}
+
+// macOS 의 작업 폴더는 lsof 로 얻는다. 프로세스마다 바뀌는 일이 드물어 pid 별로 기억한다.
+const cwdCache = new Map();
+
+function cwdOf(pid) {
+  if (HAS_PROC) {
+    try {
+      return readlinkSync(`/proc/${pid}/cwd`);
+    } catch {
+      return null;
+    }
+  }
+  if (OS !== 'darwin') return null;
+  if (cwdCache.has(pid)) return cwdCache.get(pid);
+  let cwd = null;
+  try {
+    cwd = parseLsofCwd(run('lsof', ['-a', '-p', String(pid), '-d', 'cwd', '-Fn']));
+  } catch {}
+  // 실패(lsof 없음, 시간 초과)는 기억하지 않고 다음 갱신에 다시 묻는다.
+  if (cwd) cwdCache.set(pid, cwd);
+  return cwd;
+}
+
+// 작업 폴더는 일치한 프로세스만 읽는다.
+export function findProcesses(match) {
+  const all = scanAll();
+  const found = all.filter((p) => match(p.argv));
+  // 끝난 프로세스의 pid 는 다른 프로세스가 다시 쓸 수 있으니, 지금 목록에 없는 pid 의 작업 폴더는 잊는다.
+  const alive = new Set(all.map((p) => p.pid));
+  for (const pid of cwdCache.keys()) if (!alive.has(pid)) cwdCache.delete(pid);
+  for (const pid of startCache.keys()) if (!alive.has(pid)) startCache.delete(pid);
+  return found.map((p) => ({ ...p, cwd: cwdOf(p.pid) }));
+}
+
+const base = (p) => p.split('/').pop();
+
+// `codex` 는 node 스크립트(…/bin/codex.js)이거나 네이티브 바이너리(codex-*)로 뜬다.
+export function isCodex(argv) {
+  return argv.slice(0, 2).some((a) => /^codex(\.js)?$/.test(base(a)) || /^codex-[\w-]+$/.test(base(a)));
+}
+
+export function isGemini(argv) {
+  return argv.slice(0, 2).some((a) => /^gemini(\.js)?$/.test(base(a)));
+}
+
+// Antigravity CLI 는 Go 실행 파일 하나(`agy`)로 뜬다.
+export function isAgy(argv) {
+  return argv.length > 0 && base(argv[0]) === 'agy';
+}
+
+// 프로세스가 열어 둔 파일 경로들. Linux·WSL 의 /proc 에서만 알 수 있고, 그 밖의 OS 나 읽을 권한이 없으면 null.
+export function openFiles(pid) {
+  if (!HAS_PROC) return null;
+  let fds;
+  try {
+    fds = readdirSync(`/proc/${pid}/fd`);
+  } catch {
+    return null;
+  }
+  const out = [];
+  for (const fd of fds) {
+    try {
+      out.push(readlinkSync(`/proc/${pid}/fd/${fd}`));
+    } catch {}
+  }
+  return out;
+}
+
+let ticksPerSec = null;
+let bootMs = null;
+
+// /proc/<pid>/stat 의 22번째 칸은 부팅 뒤 지난 시간(클럭 틱)이다. 명령 이름에 공백·괄호가 들 수 있어 마지막 ')' 뒤부터 센다.
+function procStartLinux(pid) {
+  if (bootMs === null) {
+    const m = /^btime (\d+)$/m.exec(readFileSync('/proc/stat', 'utf8'));
+    if (!m) return null;
+    bootMs = Number(m[1]) * 1000;
+  }
+  if (ticksPerSec === null) {
+    try {
+      ticksPerSec = Number(run('getconf', ['CLK_TCK']).trim()) || 100;
+    } catch {
+      ticksPerSec = 100;
+    }
+  }
+  const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+  const ticks = Number(stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19]);
+  return Number.isFinite(ticks) ? bootMs + (ticks / ticksPerSec) * 1000 : null;
+}
+
+// 프로세스가 시작한 시각(ms). 알 수 없으면 null. 시작 시각은 바뀌지 않으므로 pid 별로 기억한다.
+const startCache = new Map();
+
+export function processStart(pid) {
+  if (startCache.has(pid)) return startCache.get(pid);
+  let at = null;
+  try {
+    if (HAS_PROC) at = procStartLinux(pid);
+    // lstart 는 로케일에 따라 요일·달 이름이 바뀌므로 영어(C) 로케일로 받는다.
+    else if (OS === 'darwin') at = Date.parse(run('ps', ['-o', 'lstart=', '-p', String(pid)], { ...process.env, LC_ALL: 'C', LANG: 'C' }).trim()) || null;
+  } catch {}
+  if (at !== null) startCache.set(pid, at);
+  return at;
+}

package/src/sources/agy-ledger.mjs

@@ -0,0 +1,153 @@
+// 날짜별 사용량 장부의 Antigravity CLI(agy) 몫: 최근 7일 안에 바뀐 conversations/<id>.db 의 gen_metadata 를
+// 호출 시각(호출 직전 단계의 만든 시각)의 날짜와 가격으로 나눠 모은다. 서브에이전트도 대화 기록이 따로 있어 함께 센다.
+// 세션 화면과 상관없이 끝난 대화까지 세야 해서 토큰만 가볍게 따로 읽고(진행 기록은 읽지 않는다), 어디까지 읽었는지는 캐시에 둔다.
+// 기록은 늘 immutable 로 열어 agy 폴더에 아무것도 만들거나 고치지 않는다.
+import { readdirSync, statSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { AGY_ROOT, readCalls, sigOf, maxIdx } from './antigravity.mjs';
+import { openReadOnly, loadSqlite } from '../sqlite.mjs';
+import { loadCache, markDirty } from '../cache.mjs';
+import { dayKey, lastDays, addSlot } from './common.mjs';
+import { debugIo } from '../log.mjs';
+
+const KIND = 'agy-ledger';
+const DAYS = 7;
+const KEEP_DAYS = 10;
+const LIST_TTL_MS = 30_000;
+
+const outOf = (budget) => budget.left <= 0 || (budget.read > 0 && Date.now() >= (budget.deadline ?? Infinity));
+const copyDays = (days) => Object.fromEntries(Object.entries(days).map(([k, v]) => [k, { ...v }]));
+
+export class AgyBook {
+  constructor(path) {
+    this.path = path;
+    this.sig = null;
+    this.idx = -1;
+    this.model = null;
+    this.days = {};
+    // 지출 속도용 5분 칸 (common.mjs addSlot).
+    this.slots = {};
+    // 한 번이라도 끝까지 읽었는지. 처음 읽는 동안만 '집계 중' 진행률에 들어간다.
+    this.complete = false;
+    const c = loadCache(path, KIND);
+    if (c) {
+      this.idx = c.idx ?? -1;
+      this.model = c.model ?? null;
+      this.days = c.days ?? {};
+      this.slots = c.slots ?? {};
+      this.complete = true;
+    }
+  }
+
+  get size() {
+    try {
+      return statSync(this.path).size;
+    } catch {
+      return 0;
+    }
+  }
+
+  update(budget) {
+    const sig = sigOf(this.path);
+    if (sig === null || sig === this.sig) return;
+    if (outOf(budget)) {
+      budget.exhausted = true;
+      return;
+    }
+    const mainSig = sigOf(this.path, false);
+    const mtime = statSync(this.path).mtimeMs;
+    let n = { idx: this.idx, model: this.model, days: copyDays(this.days), slots: copyDays(this.slots) };
+    let db;
+    let result = null;
+    try {
+      db = openReadOnly(this.path);
+      if (!db) return;
+      const has = db.prepare("select 1 from sqlite_master where type = 'table' and name = 'gen_metadata'").get();
+      const last = has ? maxIdx(db, 'gen_metadata') : -1;
+      // 마지막 줄 번호가 줄었으면 기록이 새로 쓰인 것이니 처음부터 다시 센다.
+      if (last < n.idx) n = { idx: -1, model: null, days: {}, slots: {} };
+      result = has
+        ? readCalls(db, n, last, budget, mtime, ({ usage: u, cost, at }) => {
+            const day = (n.days[dayKey(at)] ??= { tokens: 0, cost: 0, costNoCache: 0, unknown: false });
+            const tokens = u.input + u.output + u.cacheRead + u.cacheWrite;
+            day.tokens += tokens;
+            day.cost += cost?.total ?? 0;
+            day.costNoCache += cost?.noCache ?? 0;
+            if (!cost && tokens > 0) day.unknown = true;
+            addSlot(n.slots, at, cost?.total ?? 0, cost?.noCache ?? 0, !cost && tokens > 0);
+          })
+        : 'done';
+      // 읽는 동안 agy 가 본 파일에 썼으면 읽은 내용을 버리고 다음 갱신에 다시 읽는다.
+      if (sigOf(this.path, false) !== mainSig) result = null;
+    } catch (e) {
+      debugIo('ledger', 'agy conversation read failed', e, this.path);
+      result = null;
+    } finally {
+      db?.close();
+    }
+    if (!result) return;
+    const changed = n.idx !== this.idx;
+    Object.assign(this, n);
+    if (result === 'done') {
+      this.sig = sig;
+      this.complete = true;
+    }
+    if (result === 'exhausted') budget.exhausted = true;
+    if (changed) markDirty(this.path, () => this.snapshot(), KIND);
+  }
+
+  snapshot() {
+    const keep = new Set(lastDays(KEEP_DAYS));
+    const days = Object.fromEntries(Object.entries(this.days).filter(([k]) => keep.has(k)));
+    return { offset: 0, idx: this.idx, model: this.model, days, slots: this.slots };
+  }
+}
+
+let listed = { at: 0, files: [] };
+
+function recentFiles() {
+  if (Date.now() - listed.at < LIST_TTL_MS) return listed.files;
+  const dir = join(AGY_ROOT, 'conversations');
+  const cutoff = Date.now() - DAYS * 86400_000;
+  const files = [];
+  let names = [];
+  try {
+    names = readdirSync(dir);
+  } catch (e) {
+    debugIo('ledger', 'agy conversations read failed', e);
+  }
+  for (const f of names) {
+    if (!f.endsWith('.db')) continue;
+    const p = join(dir, f);
+    try {
+      if (statSync(p).mtimeMs >= cutoff) files.push(p);
+    } catch {}
+  }
+  listed = { at: Date.now(), files };
+  return files;
+}
+
+const books = new Map();
+
+// 대화마다 날짜별 합계(days)와 5분 칸(slots), 처음 읽기가 덜 끝난 기록의 크기(pending)·전체 크기(size).
+// node:sqlite 를 못 쓰는 Node 에서는 비어 있다 (agy 는 프로세스만 보인다).
+export function collectAgyLedger({ budget } = {}) {
+  const out = { days: [], slots: [], pending: 0, size: 0 };
+  if (!loadSqlite() || !existsSync(join(AGY_ROOT, 'conversations'))) return out;
+  const files = recentFiles();
+  const keep = new Set(files);
+  for (const p of books.keys()) if (!keep.has(p)) books.delete(p);
+  for (const p of files) {
+    let b = books.get(p);
+    if (!b) books.set(p, (b = new AgyBook(p)));
+    b.update(budget);
+    const size = b.size;
+    out.size += size;
+    if (!b.complete) out.pending += size;
+    out.days.push(b.days);
+    out.slots.push(b.slots);
+  }
+  return out;
+}
+
+export const _test = { reset: () => ((listed = { at: 0, files: [] }), books.clear()) };