@geoqiao/pi-usage 0.1.0

package/vendor/vibe-usage/src/claude-roots.js

@@ -0,0 +1,165 @@
+import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { homedir } from 'node:os';
+
+const MAX_DESKTOP_DISCOVERY_DEPTH = 8;
+const DESKTOP_NON_SESSION_DIRS = new Set(['rpm', 'skills']);
+
+function expandHome(value) {
+  const trimmed = value.trim().replace(/[/\\]+$/, '');
+  if (trimmed === '~') return homedir();
+  if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    return join(homedir(), trimmed.slice(2));
+  }
+  return trimmed;
+}
+
+function hasClaudeData(root) {
+  return existsSync(join(root, 'projects')) || existsSync(join(root, 'transcripts'));
+}
+
+function defaultClaudeDesktopDataDir() {
+  if (process.platform === 'darwin') {
+    return join(homedir(), 'Library', 'Application Support', 'Claude');
+  }
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim();
+    return appData
+      ? join(expandHome(appData), 'Claude')
+      : join(homedir(), 'AppData', 'Roaming', 'Claude');
+  }
+  const configHome = process.env.XDG_CONFIG_HOME?.trim();
+  return join(configHome ? expandHome(configHome) : join(homedir(), '.config'), 'Claude');
+}
+
+function getClaudeDesktopDataDirs() {
+  const override = process.env.VIBE_USAGE_CLAUDE_DESKTOP_DIRS?.trim();
+  return override
+    ? override.split(delimiter).map(expandHome).filter(Boolean)
+    : [defaultClaudeDesktopDataDir()];
+}
+
+function discoverDesktopRoots(dir, depth, roots, onWarning) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    if (err?.code !== 'ENOENT') {
+      onWarning(`Claude Desktop: cannot read directory ${dir}: ${err.message}`);
+    }
+    return;
+  }
+
+  // Once a session root is found, do not descend into the user's Cowork files.
+  // Those directories can be large and are unrelated to Claude's transcript.
+  const claudeEntry = entries.find(
+    (entry) => entry.name === '.claude' && entry.isDirectory(),
+  );
+  if (claudeEntry) {
+    roots.push(join(dir, claudeEntry.name));
+    return;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (DESKTOP_NON_SESSION_DIRS.has(entry.name)) continue;
+    const candidate = join(dir, entry.name);
+    if (depth < MAX_DESKTOP_DISCOVERY_DEPTH) {
+      discoverDesktopRoots(candidate, depth + 1, roots, onWarning);
+    }
+  }
+}
+
+/**
+ * Find the private Claude Code state roots created for Claude Desktop Cowork.
+ * Desktop Code itself uses the normal ~/.claude root, while Cowork isolates
+ * each local-agent session below the Electron user-data directory.
+ */
+export function findClaudeDesktopRoots(
+  desktopDataDirs = getClaudeDesktopDataDirs(),
+  onWarning = () => {},
+) {
+  const roots = [];
+  for (const dataDir of desktopDataDirs) {
+    discoverDesktopRoots(
+      join(dataDir, 'local-agent-mode-sessions'),
+      0,
+      roots,
+      onWarning,
+    );
+  }
+  return roots;
+}
+
+/**
+ * Return every Claude Code-compatible state root visible from this process.
+ *
+ * In addition to the default and CLAUDE_CONFIG_DIR, discover the documented
+ * multi-profile convention (~/.claude-work, ~/.claude-personal, ...). This is
+ * important for launchd/systemd and GUI processes, which commonly do not
+ * inherit the shell environment used to launch Claude Code.
+ *
+ * Claude Desktop Code uses the default Claude Code root. Cowork creates a
+ * private .claude root per local-agent session, so those roots are discovered
+ * recursively under the app's user-data directory.
+ *
+ * VIBE_USAGE_CLAUDE_DIRS is a test/diagnostic override. It replaces all normal
+ * and Desktop discovery with a path.delimiter-separated root list.
+ */
+export function getClaudeRoots({ onWarning = () => {} } = {}) {
+  const override = process.env.VIBE_USAGE_CLAUDE_DIRS?.trim();
+  const roots = override
+    ? override.split(delimiter).map(expandHome).filter(Boolean)
+    : [join(homedir(), '.claude')];
+
+  if (!override) {
+    const configured = process.env.CLAUDE_CONFIG_DIR?.trim();
+    if (configured) roots.push(expandHome(configured));
+
+    try {
+      for (const entry of readdirSync(homedir(), { withFileTypes: true })) {
+        // Profiles are sometimes symlinked, so let hasClaudeData() follow the
+        // entry instead of requiring Dirent.isDirectory() here.
+        if (!/^\.claude-.+/.test(entry.name)) continue;
+        const candidate = join(homedir(), entry.name);
+        if (hasClaudeData(candidate)) roots.push(candidate);
+      }
+    } catch {
+      // The default/configured roots remain usable if home discovery fails.
+    }
+
+    for (const root of findClaudeDesktopRoots(getClaudeDesktopDataDirs(), onWarning)) {
+      roots.push(root);
+    }
+  }
+
+  const seen = new Set();
+  const unique = [];
+  for (const root of roots) {
+    let canonical = root;
+    try {
+      canonical = realpathSync(root);
+    } catch {
+      // Keep a missing explicit/default root so callers can report it normally.
+    }
+    if (seen.has(canonical)) continue;
+    seen.add(canonical);
+    unique.push(root);
+  }
+  return unique;
+}
+
+export function findClaudeCodeDataDirs() {
+  const dirs = [];
+  for (const root of getClaudeRoots()) {
+    for (const name of ['projects', 'transcripts']) {
+      const candidate = join(root, name);
+      try {
+        if (statSync(candidate).isDirectory()) dirs.push(candidate);
+      } catch {
+        // Missing or unreadable roots are handled by the parser.
+      }
+    }
+  }
+  return dirs;
+}

package/vendor/vibe-usage/src/cline-roots.js

@@ -0,0 +1,40 @@
+import { statSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { homedir } from 'node:os';
+
+const EXTENSION_ID = 'saoudrizwan.claude-dev';
+const HOSTS = ['Code', 'Cursor', 'Windsurf', 'VSCodium', 'Code - Insiders', 'Trae', 'Trae CN'];
+
+function hasTaskHistory(root) {
+  try {
+    return statSync(join(root, 'state', 'taskHistory.json')).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function hostRoots() {
+  const out = [];
+  if (process.platform === 'darwin') {
+    const base = join(homedir(), 'Library', 'Application Support');
+    for (const host of HOSTS) out.push(join(base, host));
+  } else if (process.platform === 'win32') {
+    const base = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+    for (const host of HOSTS) out.push(join(base, host));
+  } else {
+    const base = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+    for (const host of HOSTS) out.push(join(base, host));
+  }
+  return out;
+}
+
+export function findClineDataDirs() {
+  const override = process.env.VIBE_USAGE_CLINE_DIRS?.trim();
+  const candidates = override
+    ? override.split(delimiter).map((value) => value.trim()).filter(Boolean)
+    : [
+        join(homedir(), '.cline'),
+        ...hostRoots().map((root) => join(root, 'User', 'globalStorage', EXTENSION_ID)),
+      ];
+  return [...new Set(candidates)].filter(hasTaskHistory);
+}

package/vendor/vibe-usage/src/codex-roots.js

@@ -0,0 +1,46 @@
+import { statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+function normalizeHomePath(value) {
+  const trimmed = value.trim();
+  if (trimmed === '~') return homedir();
+  if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    return resolve(homedir(), trimmed.slice(2));
+  }
+  return resolve(trimmed);
+}
+
+export function primaryCodexHome() {
+  const configured = process.env.CODEX_HOME?.trim();
+  return configured ? normalizeHomePath(configured) : join(homedir(), '.codex');
+}
+
+export function resolveCodexHomes(extraCodexHome) {
+  const roots = [primaryCodexHome()];
+  if (extraCodexHome?.trim()) roots.push(normalizeHomePath(extraCodexHome));
+  return [...new Set(roots)];
+}
+
+export function codexSessionDirs(codexHome) {
+  return [
+    join(codexHome, 'sessions'),
+    join(codexHome, 'archived_sessions'),
+  ];
+}
+
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export function validateExtraCodexHome(value) {
+  const path = normalizeHomePath(value);
+  return {
+    ok: isDirectory(path) && codexSessionDirs(path).some(isDirectory),
+    path,
+  };
+}

package/vendor/vibe-usage/src/craft-roots.js

@@ -0,0 +1,15 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export function getCraftWorkspacesDir() {
+  const root = process.env.CRAFT_AGENT_DIR?.trim()
+    || process.env.CRAFTAGENT_DIR?.trim()
+    || join(homedir(), '.craft-agent');
+  return join(root, 'workspaces');
+}
+
+export function findCraftDataDirs() {
+  const workspaces = getCraftWorkspacesDir();
+  return existsSync(workspaces) ? [workspaces] : [];
+}

package/vendor/vibe-usage/src/extra-roots.js

@@ -0,0 +1,312 @@
+import { accessSync, closeSync, constants, openSync, readSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import { codexSessionDirs } from './codex-roots.js';
+
+export const EXTRA_ROOT_SOURCES = ['antigravity', 'codex', 'grok', 'pi-coding-agent'];
+
+// Probing a candidate Pi store has three outcomes, never two: a confirmed
+// session, a directory proven to hold none, and one that could not be read.
+// Collapsing the last two into a single false is what let an unreadable subtree
+// be treated as an empty one.
+const PI_SESSIONS_FOUND = 'found';
+const PI_SESSIONS_ABSENT = 'absent';
+const PI_SESSIONS_UNREADABLE = 'unreadable';
+
+export function extraRootList(value) {
+  return Array.isArray(value) ? value.filter(root => typeof root === 'string' && root.trim()) : [];
+}
+
+export function normalizeExtraRoot(value) {
+  const trimmed = value.trim();
+  if (trimmed === '~') return homedir();
+  if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    return resolve(homedir(), trimmed.slice(2));
+  }
+  return resolve(trimmed);
+}
+
+function isReadableDirectory(path) {
+  try {
+    if (!statSync(path).isDirectory()) return false;
+    accessSync(path, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isCodexHome(path) {
+  return isReadableDirectory(path) && codexSessionDirs(path).some(isReadableDirectory);
+}
+
+// Multica stores task-local Codex homes below a bounded
+// <container>/<workspace>/<task>/codex-home hierarchy. Do not follow symlinks
+// or descend beyond that shape: configured containers may also contain large
+// workdirs that are unrelated to usage logs.
+export function discoverCodexHomes(value, maxDepth = 3) {
+  const root = normalizeExtraRoot(value);
+  if (isCodexHome(root)) return { root, homes: [root], readable: true };
+  if (!isReadableDirectory(root)) return { root, homes: [], readable: false };
+
+  const homes = [];
+  const queue = [{ path: root, depth: 0 }];
+  let readable = true;
+  while (queue.length > 0) {
+    const current = queue.shift();
+    let children;
+    try {
+      children = readdirSync(current.path, { withFileTypes: true });
+    } catch {
+      readable = false;
+      continue;
+    }
+    for (const child of children) {
+      // Dirent#isDirectory is false for symbolic links, so traversal stays
+      // inside the explicitly selected tree.
+      if (!child.isDirectory()) continue;
+      const childPath = join(current.path, child.name);
+      const depth = current.depth + 1;
+      if (basename(childPath) === 'codex-home' && isCodexHome(childPath)) {
+        homes.push(childPath);
+        continue;
+      }
+      if (depth < maxDepth) queue.push({ path: childPath, depth });
+    }
+  }
+  return { root, homes: [...new Set(homes)], readable };
+}
+
+export function grokSessionsDir(value) {
+  return join(normalizeExtraRoot(value), 'sessions');
+}
+
+export function antigravityConversationDirs(value) {
+  const root = normalizeExtraRoot(value);
+  return [
+    join(root, '.gemini', 'antigravity', 'conversations'),
+    join(root, '.gemini', 'antigravity-cli', 'conversations'),
+  ];
+}
+
+// Pi's own discoverable settings (PI_CODING_AGENT_SESSION_DIR, `sessionDir` in
+// settings.json) name a sessions directory directly, and a harness that calls
+// `pi --session <file>` writes bare session trees with no agent home above
+// them. Accept either shape, but resolve to exactly one directory per root:
+// the parser walks nested directories, so returning both a root and its
+// `sessions/` child would read every file twice. Canonical-path dedup in the
+// parser makes the overlap harmless even for a mixed root that holds sessions
+// directly *and* under `sessions/`.
+//
+// Every candidate is confirmed by content, never by name alone. A readable but
+// unconfirmed `sessions/` child used to win unconditionally, so creating an
+// empty `<root>/sessions` was enough to redirect the scan away from a bare
+// store's own files — a successful sync reporting zero, which then pruned the
+// source's incremental state.
+//
+// The shape is re-resolved on every run rather than remembered from add-root
+// time, and an unresolvable root returns null instead of falling back to the
+// root itself. Falling back would turn an agent home that lost its `sessions/`
+// child into a readable directory holding no sessions, i.e. exactly the silent
+// zero this feature exists to prevent.
+//
+// Probing is tri-state on purpose. A boolean collapsed "holds no sessions" into
+// "could not be read", so making one sibling store unreadable was enough to
+// make a container look like an agent home and narrow the scan to `sessions/`,
+// dropping every readable sibling with no `skipped` flag. Absence has to be
+// proven; where it is only assumed, resolution gives up and the caller skips.
+export function piSessionsDir(value) {
+  const root = normalizeExtraRoot(value);
+  if (!isReadableDirectory(root)) return null;
+  // A bare store is identified by the session files it holds directly, and
+  // outranks any `sessions/` child: those files are what the user configured.
+  const direct = probePiSessions(root, 0);
+  if (direct === PI_SESSIONS_FOUND) return root;
+
+  const outside = probePiSessionsOutsideNested(root);
+  // Both decisions below rest on absence: that the root holds no sessions
+  // directly, and that no sibling of `sessions/` holds any. An unreadable
+  // candidate proves neither, so stop rather than narrow past it.
+  if (direct === PI_SESSIONS_UNREADABLE || outside === PI_SESSIONS_UNREADABLE) return null;
+
+  const nested = join(root, 'sessions');
+  // Agent-home shape: narrowing to the child is only safe when every confirmed
+  // session lives below it. A container whose per-task stores happen to include
+  // one named `sessions` is still a container, and resolving it to that child
+  // would drop all its siblings — the same silent undercount as above.
+  if (
+    outside === PI_SESSIONS_ABSENT
+    && isReadableDirectory(nested)
+    && probePiSessions(nested) === PI_SESSIONS_FOUND
+  ) {
+    return nested;
+  }
+  // A configured container holding per-task stores somewhere below it. Anything
+  // else — no sessions at all, or a subtree that could not be read — resolves
+  // to null, which the parser reports as skipped instead of as an empty sync.
+  return probePiSessions(root) === PI_SESSIONS_FOUND ? root : null;
+}
+
+// Confirmed sessions in some child other than `sessions/`. The per-child depth
+// is one less than the root scan's own so both reach the same files.
+function probePiSessionsOutsideNested(root) {
+  let children;
+  try {
+    children = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return PI_SESSIONS_UNREADABLE;
+  }
+  let unreadable = false;
+  for (const child of children) {
+    if (!child.isDirectory() || child.name === 'sessions') continue;
+    const probe = probePiSessions(join(root, child.name), 1);
+    if (probe === PI_SESSIONS_FOUND) return PI_SESSIONS_FOUND;
+    if (probe === PI_SESSIONS_UNREADABLE) unreadable = true;
+  }
+  return unreadable ? PI_SESSIONS_UNREADABLE : PI_SESSIONS_ABSENT;
+}
+
+const PI_PROBE_BYTES = 16 * 1024;
+const PI_PROBE_LINES = 10;
+// Roles the Pi parser turns into events; anything else contributes nothing.
+const PI_MESSAGE_ROLES = new Set(['user', 'assistant', 'toolResult']);
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim() !== '';
+}
+
+// Pi's session format opens a store with a full SessionHeader. `version` is
+// written as both a number and a string across real stores, so only its
+// presence is required.
+function isPiSessionHeader(obj) {
+  return obj.type === 'session'
+    && obj.version !== undefined
+    && obj.version !== null
+    && isNonEmptyString(obj.id)
+    && isNonEmptyString(obj.timestamp)
+    && typeof obj.cwd === 'string';
+}
+
+// A store an external harness appends to may carry no header inside the probed
+// prefix, so a message record alone can confirm the directory — but only a
+// complete one. Matching on `type` and an object-valued `message` accepted
+// `{"type":"message","message":{}}`, which the parser reads to exactly zero.
+function isPiSessionMessage(obj) {
+  return obj.type === 'message'
+    && isNonEmptyString(obj.id)
+    && 'parentId' in obj
+    && isNonEmptyString(obj.timestamp)
+    && Boolean(obj.message)
+    && typeof obj.message === 'object'
+    && PI_MESSAGE_ROLES.has(obj.message.role);
+}
+
+// A `.jsonl` extension proves nothing: an unrelated log would validate an
+// entirely wrong directory, which the parser then ignores without complaining.
+// Neither does a bare `type` name — validation has to require the fields the
+// parser reads, or a malformed lookalike is accepted and still syncs zero.
+// A file that cannot be opened is reported as unreadable, not as "not a
+// session": it may well be the store the user configured.
+function probePiSessionFile(filePath) {
+  let text;
+  let fd;
+  try {
+    fd = openSync(filePath, 'r');
+    const buffer = Buffer.alloc(PI_PROBE_BYTES);
+    const read = readSync(fd, buffer, 0, PI_PROBE_BYTES, 0);
+    text = buffer.subarray(0, read).toString('utf8');
+    // A prefix read can cut the final line in half; drop the partial tail.
+    if (read === PI_PROBE_BYTES) text = text.slice(0, text.lastIndexOf('\n') + 1);
+  } catch {
+    return PI_SESSIONS_UNREADABLE;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync(fd);
+      } catch { /* already closed */ }
+    }
+  }
+
+  let checked = 0;
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    if (++checked > PI_PROBE_LINES) return PI_SESSIONS_ABSENT;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!obj || typeof obj !== 'object') continue;
+    if (isPiSessionHeader(obj) || isPiSessionMessage(obj)) return PI_SESSIONS_FOUND;
+  }
+  return PI_SESSIONS_ABSENT;
+}
+
+// A session store is only recognizable by the Pi session files in it. Stay
+// shallow: a configured root may sit next to large unrelated trees.
+//
+// `found` outranks `unreadable`: one confirmed session is enough to resolve the
+// shape, and the shared parser reports whatever it cannot read on the way in.
+// `unreadable` outranks `absent`, so a caller never mistakes a subtree it could
+// not open for one it proved empty.
+function probePiSessions(dir, depth = 2) {
+  let children;
+  try {
+    children = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return PI_SESSIONS_UNREADABLE;
+  }
+  let unreadable = false;
+  // Dirent#isDirectory is false for symbolic links, matching the parser's own
+  // walk: linked session files are read, linked directories are not entered.
+  for (const child of children) {
+    if (child.isDirectory() || !child.name.endsWith('.jsonl')) continue;
+    const probe = probePiSessionFile(join(dir, child.name));
+    if (probe === PI_SESSIONS_FOUND) return PI_SESSIONS_FOUND;
+    if (probe === PI_SESSIONS_UNREADABLE) unreadable = true;
+  }
+  if (depth > 0) {
+    for (const child of children) {
+      if (!child.isDirectory()) continue;
+      const probe = probePiSessions(join(dir, child.name), depth - 1);
+      if (probe === PI_SESSIONS_FOUND) return PI_SESSIONS_FOUND;
+      if (probe === PI_SESSIONS_UNREADABLE) unreadable = true;
+    }
+  }
+  return unreadable ? PI_SESSIONS_UNREADABLE : PI_SESSIONS_ABSENT;
+}
+
+export function validateExtraRoot(source, value) {
+  if (!EXTRA_ROOT_SOURCES.includes(source)) {
+    return { ok: false, path: value, reason: `不支持的工具: ${source}` };
+  }
+  const path = normalizeExtraRoot(value);
+  if (source === 'codex') {
+    const result = discoverCodexHomes(path);
+    return {
+      ok: result.readable && result.homes.length > 0,
+      path,
+      reason: '需要是 Codex Home，或包含 */*/codex-home 的 Multica 容器',
+    };
+  }
+  if (source === 'pi-coding-agent') {
+    // piSessionsDir only returns a directory it has already confirmed by
+    // content, so there is nothing left to re-check here.
+    return {
+      ok: piSessionsDir(path) !== null,
+      path,
+      reason: '需要是直接包含 Pi 会话 .jsonl 的目录，或包含 sessions/ 的 Pi agent 目录',
+    };
+  }
+  const dirs = source === 'grok'
+    ? [grokSessionsDir(path)]
+    : antigravityConversationDirs(path);
+  return {
+    ok: dirs.some(isReadableDirectory),
+    path,
+    reason: source === 'grok'
+      ? '需要包含 sessions/'
+      : '需要包含 .gemini/antigravity*/conversations/',
+  };
+}