@vibe-cafe/vibe-usage 0.10.22 → 0.10.24

package/README.md

@@ -80,6 +80,8 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Antigravity | Scans App 2.0 `~/.gemini/antigravity/conversations/`, `agy` CLI `~/.gemini/antigravity-cli/conversations/`, and standalone IDE `~/.gemini/antigravity-ide/conversations/`. `.db` stores, including the same paths below explicitly added alternate Homes, are parsed offline (tokens, model, project, sessions). When Gemini blobs omit `chatStartMetadata.createdAt` or `modelDisplayName`, timestamps fall back to `steps.metadata` and model names to `responseModel`. `.pb` history in the default stores requires the corresponding App/IDE language server to be running; when several servers are open, the parser tries the others for unreadable conversations. Unavailable legacy history produces a warning and preserves prior sync state. |
 | WorkBuddy | Current releases: `~/.workbuddy-ai/projects/**/*.jsonl`; legacy releases: `~/.workbuddy/projects/**/*.jsonl` (fixture/relocation override: `VIBE_USAGE_WORKBUDDY_DIRS`). Reads usage-bearing completed assistant and `function_call` records, using the routed model identifier exposed as `providerData.requestModelId`. Splits cache reads and reasoning from inclusive input/output totals, deduplicates copied record IDs, and extracts local session timing without uploading message content. |
 | ZCode | `~/.zcode/cli/db/db.sqlite` (SQLite; reads the `message` table for per-message tokens, model, and project `cwd`/`root`, joined to `session.directory`) |
+| Qoder | International edition (qoder.com). IDE store `~/Library/Application Support/Qoder/SharedClientCache/cache/db/local.db` (Windows `%APPDATA%\Qoder`, Linux `~/.config/Qoder`; honors `QODER_HOME`, fixture override `VIBE_USAGE_QODER_DB`) gives real tokens from `chat_message.token_info` (prompt includes cached; split out) with `model_key` usually a routing tier, reported as `qoder-auto` / `qoder-ultimate` / … so it never collides with a priced model id; message content is never selected, and lock/schema failures fall back to a snapshot or `skipped`. CLI + desktop app transcripts `~/.qoder/projects/**/*.jsonl` (honors `QODER_CONFIG_DIR`, fixture override `VIBE_USAGE_QODER_PROJECTS`; sub-agents under `<session>/subagents/`) are credit-billed with every token field at 0, so they contribute sessions only — credits are account funding and are not collected |
+| Qoder CN | China edition (qoder.com.cn, separate account). Same two shapes under `~/Library/Application Support/QoderCN/SharedClientCache/cache/db/local.db` (`QODER_CN_HOME` / `VIBE_USAGE_QODER_CN_DB`) and `~/.qoder-cn/projects/` (`QODERCN_CONFIG_DIR` / `VIBE_USAGE_QODER_CN_PROJECTS`); reported as source `qoder-cn` |
 
 ## How It Works
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.10.22",
+  "version": "0.10.24",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "scripts": {

package/src/api.js

@@ -280,6 +280,39 @@ export function getJson(apiUrl, apiKey, path, { timeoutMs = 15_000 } = {}) {
   });
 }
 
+/**
+ * Which vibecafe account this API key is bound to.
+ *
+ * Exists because a key minted against the wrong account is otherwise invisible
+ * from the client side: ingest and this endpoint both answer 200 for it, so the
+ * user sees a healthy CLI and a healthy desktop app while their uploads pile up
+ * on an account they never look at. Ask the backend whose data it is and say so.
+ *
+ * Returns null when the backend is too old to send `account`, or on any
+ * transient failure — identity is a nicety, never a reason to fail a command.
+ * UNAUTHORIZED still propagates: that one the caller must not swallow.
+ *
+ * @param {string} apiUrl
+ * @param {string} apiKey
+ * @returns {Promise<{handle: string, name: string | null} | null>}
+ */
+export async function fetchAccount(apiUrl, apiKey) {
+  let data;
+  try {
+    // bucketsOnly keeps the response to the aggregate we throw away; days=1
+    // keeps the window (and the scan) small.
+    data = await getJson(apiUrl, apiKey, '/api/usage?days=1&bucketsOnly=true', { timeoutMs: 10_000 });
+  } catch (err) {
+    if (err.message === 'UNAUTHORIZED') throw err;
+    return null;
+  }
+  const account = data?.account;
+  if (account && typeof account.handle === 'string') {
+    return { handle: account.handle, name: account.name ?? null };
+  }
+  return null;
+}
+
 /**
  * GET user settings from the vibecafe API.
  * Returns null after transient failures are exhausted. A 401 remains distinct

package/src/index.js

@@ -8,7 +8,8 @@ import {
   normalizeExtraRoot,
   validateExtraRoot,
 } from './extra-roots.js';
-import { failure, smallHeader } from './output.js';
+import { dim as dimText, failure, smallHeader, warn } from './output.js';
+import { fetchAccount } from './api.js';
 
 function printSmallHeader() {
   console.log();
@@ -27,6 +28,8 @@ async function showStatus() {
     console.log(`  Config: ${getConfigPath()}`);
     console.log(`  API key: ${config.apiKey.slice(0, 8)}...`);
     console.log(`  API URL: ${config.apiUrl || 'https://vibecafe.ai'}`);
+    // 数据算在谁名下,是这里最该回答、以前偏偏答不出的一件事。
+    await printBoundAccount(config.apiUrl || 'https://vibecafe.ai', config.apiKey);
     if (config.codexExtraHome) {
       console.log(`  Extra Codex Home: ${config.codexExtraHome}`);
     }
@@ -62,6 +65,30 @@ async function showStatus() {
   console.log();
 }
 
+/**
+ * Print the account this key uploads to. Never throws: an offline machine or an
+ * older backend just means we cannot name the account, which must not make
+ * `status` fail — but a revoked/invalid key is worth saying out loud.
+ */
+async function printBoundAccount(apiUrl, apiKey) {
+  try {
+    const account = await fetchAccount(apiUrl, apiKey);
+    if (account) {
+      const label = account.name ? `@${account.handle}(${account.name})` : `@${account.handle}`;
+      console.log(`  账号: ${label}`);
+      console.log(dimText(`        数据都记在这个账号名下,不是它就换个账号重新 init`));
+    } else {
+      console.log(dimText('  账号: 服务端未返回(后端版本较旧或网络异常)'));
+    }
+  } catch (err) {
+    if (err.message === 'UNAUTHORIZED') {
+      console.log(warn('账号: Key 已失效,请重新运行 `npx @vibe-cafe/vibe-usage init`'));
+      return;
+    }
+    console.log(dimText('  账号: 读取失败'));
+  }
+}
+
 const VALID_CONFIG_KEYS = ['apiKey', 'apiUrl', 'hostname', 'codexExtraHome'];
 
 function handleConfig(args) {

package/src/init.js

@@ -2,7 +2,7 @@ import { createInterface } from 'node:readline';
 import { execFile } from 'node:child_process';
 import { hostname as osHostname, platform } from 'node:os';
 import { loadConfig, saveConfig } from './config.js';
-import { ingest, requestDeviceCode, pollDeviceCode } from './api.js';
+import { fetchAccount, ingest, requestDeviceCode, pollDeviceCode } from './api.js';
 import { runSync } from './sync.js';
 import { detectInstalledTools } from './tools.js';
 import { bigHeader, success, failure, warn, arrow, link, dim, divider } from './output.js';
@@ -68,6 +68,13 @@ export async function runInit(options = {}) {
   try {
     await ingest(apiUrl, apiKey, []);
     console.log(success(`验证通过 ${dim(apiKey.slice(0, 12) + '...')}`));
+    // 说清楚数据会算在谁名下 —— 授权那一刻浏览器里登录的可能并不是他自己以为的
+    // 那个账号,而这是整条链路上最后一次能当场发现的机会。
+    const account = await fetchAccount(apiUrl, apiKey).catch(() => null);
+    if (account) {
+      console.log(success(`已链接到账号 ${account.name ? `@${account.handle}(${account.name})` : `@${account.handle}`}`));
+      console.log(dim('  数据都会记在这个账号名下;不是你要的账号就退出登录后重新 init。'));
+    }
   } catch (err) {
     if (err.message === 'UNAUTHORIZED') {
       console.error(failure('API Key 无效，请检查后重试。'));

package/src/parsers/index.js

@@ -26,6 +26,7 @@ import { parse as parsePiCodingAgent } from './pi-coding-agent.js';
 import { parse as parseZcode } from './zcode.js';
 import { parse as parseTraeCli } from './trae-cli.js';
 import { parse as parseWorkbuddy } from './workbuddy.js';
+import { parseQoder, parseQoderCn } from './qoder.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
@@ -40,6 +41,8 @@ export const parsers = {
   'openclaw': parseOpenclaw,
   'omp': parseOmp,
   'pi-coding-agent': parsePiCodingAgent,
+  'qoder': parseQoder,
+  'qoder-cn': parseQoderCn,
   'qwen-code': parseQwenCode,
   'kimi-code': parseKimiCode,
   'amp': parseAmp,

package/src/parsers/qoder.js

@@ -0,0 +1,334 @@
+import { createReadStream, existsSync, readdirSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { join, basename, extname } from 'node:path';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { projectFromCwd, toCount } from './fs-utils.js';
+import { isSqliteUnavailableError, queryDbJsonSnapshotOnLock, sqliteUnavailableError } from './sqlite.js';
+import { QODER_EDITIONS, getQoderProjectsDir, getQoderDbPath } from '../qoder-roots.js';
+
+/**
+ * Qoder (Alibaba's agentic coding platform). Two editions with fully separate
+ * accounts, billing, model pools and data directories — see ../qoder-roots.js:
+ *
+ *   'qoder'     international qoder.com     ~/.qoder      Application Support/Qoder
+ *   'qoder-cn'  China qoder.com.cn          ~/.qoder-cn   Application Support/QoderCN
+ *
+ * Each edition has two local data shapes, verified on 2026-09-04 against
+ * Qoder CLI 1.1.42, Qoder desktop app 0.1.6 and both IDEs 1.28.0:
+ *
+ * 1. The IDE's SQLite store <ideDataDir>/SharedClientCache/cache/db/local.db:
+ *    table chat_message with `token_info` JSON { prompt_tokens, cached_tokens,
+ *    completion_tokens, max_input_tokens } and `model_info` JSON { model_key }.
+ *    Real tokens (prompt_tokens INCLUDES cached_tokens), no credits. `model_key`
+ *    is usually a routing tier ('auto', 'ultimate', 'performance', 'efficient',
+ *    'lite') rather than a concrete model; tiers are reported as `qoder-<tier>`
+ *    so they stay unmatched server-side (see normalizeQoderModel).
+ *    → token buckets + sessions.
+ *
+ * 2. JSONL transcripts (CLI + desktop app share them — the app embeds the CLI):
+ *    <configDir>/projects/<cwd-slug>/<sessionId>.jsonl plus sub-agent files at
+ *    <configDir>/projects/<cwd-slug>/<sessionId>/subagents/agent-*.jsonl.
+ *    Claude Code-shaped records { type, timestamp, uuid, sessionId, cwd,
+ *    message:{ id, role, model, content, usage } }. Qoder bills these in
+ *    CREDITS: `message.usage` is { input_tokens:0, output_tokens:0, …,
+ *    credits, original_credits, billable } — every token field is 0. One
+ *    assistant message is written as several lines (one per content block);
+ *    only the last line of a message carries `usage`.
+ *    → sessions only. The credit amount is an account funding path and is not
+ *    collected (cost-accounting invariant in AGENTS.md); token fields are read
+ *    so that a future Qoder build that reports tokens is counted without a
+ *    parser change.
+ */
+
+const DEFAULT_MODEL = 'qoder-agent';
+const MAX_WARNINGS = 10;
+
+// Qoder's routing tiers are not models. Left bare, `auto` collides with the
+// Cursor `auto` entry in the server pricing map and gets billed at Cursor's
+// rate, so tiers are namespaced (`qoder-auto`, …) — those never match a price
+// and render as unmatched, which is the truthful state. Concrete model keys
+// (`qmodel_38max`, …) are passed through unchanged.
+const ROUTING_TIERS = new Set(['auto', 'ultimate', 'performance', 'efficient', 'lite']);
+
+function normalizeQoderModel(key) {
+  const k = typeof key === 'string' ? key.trim() : '';
+  if (!k) return DEFAULT_MODEL;
+  return ROUTING_TIERS.has(k.toLowerCase()) ? `qoder-${k.toLowerCase()}` : k;
+}
+
+function toDate(value) {
+  if (value == null || value === '') return null;
+  if (typeof value === 'number') {
+    const ms = value < 1e12 ? value * 1000 : value;
+    const d = new Date(ms);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  const s = String(value).trim();
+  if (/^\d+(\.\d+)?$/.test(s)) return toDate(Number(s));
+  const d = new Date(s);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+function warn(ctx, message) {
+  if (ctx.warnings.length < MAX_WARNINGS) ctx.warnings.push(`${ctx.source}: ${message}`);
+}
+
+// ── JSONL layer (CLI + desktop app) ────────────────────────────────────────
+
+function listJsonlFiles(root, ctx) {
+  const out = [];
+  const walk = dir => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch (err) {
+      ctx.skipped = true;
+      warn(ctx, `cannot read ${dir}: ${err.message}`);
+      return;
+    }
+    for (const entry of entries) {
+      const p = join(dir, entry.name);
+      if (entry.isDirectory()) walk(p);
+      else if (entry.isFile() && extname(entry.name) === '.jsonl') out.push(p);
+    }
+  };
+  walk(root);
+  return out;
+}
+
+// A `user` record is a human prompt unless it is a tool result being fed back.
+function isHumanPrompt(record) {
+  if (record.humanInput) return true;
+  if (record.origin && record.origin.kind === 'human') return true;
+  if (record.toolUseResult) return false;
+  const content = record.message?.content;
+  if (Array.isArray(content)) {
+    return !content.some(c => c && typeof c === 'object' && c.type === 'tool_result');
+  }
+  return true;
+}
+
+async function parseTranscriptFile(filePath, ctx) {
+  const { source, entries, events } = ctx;
+  const fallbackSession = basename(filePath, '.jsonl');
+  // One assistant message spans several lines; keep the last usage-bearing
+  // record per message id so a call is counted exactly once.
+  const usageByMessage = new Map();
+
+  const rl = createInterface({ input: createReadStream(filePath, { encoding: 'utf-8' }), crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!record || typeof record !== 'object') continue;
+    const type = record.type;
+    if (type !== 'user' && type !== 'assistant') continue;
+
+    const timestamp = toDate(record.timestamp);
+    if (!timestamp) continue;
+    const sessionId = record.sessionId || record.session_id || fallbackSession;
+    const project = projectFromCwd(record.cwd);
+    const message = record.message && typeof record.message === 'object' ? record.message : {};
+
+    if (type === 'user') {
+      if (isHumanPrompt(record)) {
+        events.push({ sessionId, source, project, timestamp, role: 'user' });
+      }
+      continue;
+    }
+
+    events.push({ sessionId, source, project, timestamp, role: 'assistant' });
+
+    const usage = message.usage;
+    if (!usage || typeof usage !== 'object') continue;
+    const key = `${sessionId}|${message.id || record.uuid || `${filePath}:${usageByMessage.size}`}`;
+    usageByMessage.set(key, {
+      usage,
+      model: normalizeQoderModel(message.model),
+      project,
+      timestamp,
+    });
+  }
+
+  for (const { usage, model, project, timestamp } of usageByMessage.values()) {
+    // Cache writes join input (same convention as the Claude Code parser).
+    const input = toCount(usage.input_tokens) + toCount(usage.cache_creation_input_tokens);
+    const cached = toCount(usage.cache_read_input_tokens ?? usage.cached_tokens);
+    const output = toCount(usage.output_tokens);
+    if (input + cached + output === 0) continue; // credit-billed call: tokens not reported
+    entries.push({
+      source,
+      model,
+      project,
+      timestamp,
+      inputTokens: input,
+      outputTokens: output,
+      cachedInputTokens: cached,
+      reasoningOutputTokens: 0,
+    });
+  }
+}
+
+async function parseTranscripts(edition, ctx) {
+  const root = getQoderProjectsDir(edition);
+  if (!existsSync(root)) return;
+  for (const file of listJsonlFiles(root, ctx)) {
+    try {
+      await parseTranscriptFile(file, ctx);
+    } catch (err) {
+      // A half-written or unreadable transcript: keep prior upload state, retry next run.
+      ctx.skipped = true;
+      warn(ctx, `cannot read ${file}: ${err.message}`);
+    }
+  }
+}
+
+// ── SQLite layer (IDE) ─────────────────────────────────────────────────────
+
+const IDE_COLUMNS = `
+  cm.id AS id,
+  cm.session_id AS sessionId,
+  cm.request_id AS requestId,
+  cm.role AS role,
+  cm.token_info AS tokenInfo,
+  cm.model_info AS modelInfo,
+  cm.gmt_create AS created`;
+
+// Only token/model/timing columns are selected; message content, tool results
+// and summaries are never read.
+const IDE_QUERY_WITH_SESSION = `SELECT ${IDE_COLUMNS},
+  cs.project_uri AS projectUri,
+  cs.project_name AS projectName,
+  cs.preferred_model_info AS preferredModelInfo
+  FROM chat_message cm
+  LEFT JOIN chat_session cs ON cs.session_id = cm.session_id
+  WHERE cm.role IN ('user', 'assistant')`;
+
+const IDE_QUERY_PLAIN = `SELECT ${IDE_COLUMNS}
+  FROM chat_message cm
+  WHERE cm.role IN ('user', 'assistant')`;
+
+function isMissingTable(err, table) {
+  return err && typeof err.message === 'string' && new RegExp(`no such table:\\s*${table}`, 'i').test(err.message);
+}
+
+function queryIdeRows(dbPath) {
+  const opts = { tempPrefix: 'vibe-usage-qoder-' };
+  try {
+    return queryDbJsonSnapshotOnLock(dbPath, IDE_QUERY_WITH_SESSION, opts);
+  } catch (err) {
+    // Older Qoder CN builds have no chat_session table; degrade to unattributed projects.
+    if (isMissingTable(err, 'chat_session')) return queryDbJsonSnapshotOnLock(dbPath, IDE_QUERY_PLAIN, opts);
+    if (isMissingTable(err, 'chat_message')) return [];
+    throw err;
+  }
+}
+
+function parseJson(value) {
+  if (!value) return null;
+  if (typeof value === 'object') return value;
+  try {
+    const parsed = JSON.parse(String(value));
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function ideProject(row) {
+  const uri = typeof row.projectUri === 'string' ? row.projectUri.trim() : '';
+  if (uri) {
+    if (uri.startsWith('file://')) {
+      try {
+        return projectFromCwd(decodeURIComponent(new URL(uri).pathname));
+      } catch {
+        // fall through to project_name
+      }
+    } else {
+      return projectFromCwd(uri);
+    }
+  }
+  const name = typeof row.projectName === 'string' ? row.projectName.trim() : '';
+  // '.' is Qoder's "no project" sentinel.
+  return name && name !== '.' ? name : 'unknown';
+}
+
+function ideModel(row) {
+  const info = parseJson(row.modelInfo);
+  const preferred = parseJson(row.preferredModelInfo);
+  const key = info?.model_key || info?.modelKey || preferred?.model_key || preferred?.modelKey;
+  return normalizeQoderModel(key);
+}
+
+function parseIde(edition, ctx) {
+  const { source, entries, events } = ctx;
+  const dbPath = getQoderDbPath(edition);
+  if (!existsSync(dbPath)) return;
+
+  let rows;
+  try {
+    rows = queryIdeRows(dbPath);
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError(`${QODER_EDITIONS[edition].label} IDE`);
+    // Schema drift or a transient read failure: fail soft so incremental state
+    // for this source is not pruned.
+    ctx.skipped = true;
+    warn(ctx, `cannot read ${dbPath}: ${err.message}`);
+    return;
+  }
+
+  for (const row of rows) {
+    const timestamp = toDate(row.created);
+    if (!timestamp) continue;
+    const project = ideProject(row);
+    const sessionId = row.sessionId || 'unknown';
+    const role = row.role === 'user' ? 'user' : 'assistant';
+    events.push({ sessionId, source, project, timestamp, role });
+    if (role !== 'assistant') continue;
+
+    const tokens = parseJson(row.tokenInfo);
+    if (!tokens) continue;
+    const prompt = toCount(tokens.prompt_tokens);
+    const cached = Math.min(prompt, toCount(tokens.cached_tokens));
+    const completion = toCount(tokens.completion_tokens);
+    if (prompt + completion === 0) continue;
+
+    entries.push({
+      source,
+      model: ideModel(row),
+      project,
+      timestamp,
+      // prompt_tokens already includes cached_tokens.
+      inputTokens: prompt - cached,
+      outputTokens: completion,
+      cachedInputTokens: cached,
+      reasoningOutputTokens: 0,
+    });
+  }
+}
+
+// ── Entry points ───────────────────────────────────────────────────────────
+
+async function parseEdition(edition) {
+  const ctx = { source: QODER_EDITIONS[edition].source, entries: [], events: [], warnings: [], skipped: false };
+  await parseTranscripts(edition, ctx);
+  parseIde(edition, ctx);
+  return {
+    buckets: aggregateToBuckets(ctx.entries),
+    sessions: extractSessions(ctx.events),
+    skipped: ctx.skipped,
+    warnings: ctx.warnings,
+  };
+}
+
+export async function parseQoder() {
+  return parseEdition('qoder');
+}
+
+export async function parseQoderCn() {
+  return parseEdition('qoder-cn');
+}

package/src/qoder-roots.js

@@ -0,0 +1,82 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+// Path resolution for the two Qoder editions (same role as the other *-roots.js
+// modules: shared by tools.js detection and the parser, free of parser imports).
+//
+//   edition     CLI config dir   IDE data dir (macOS)
+//   'qoder'     ~/.qoder         ~/Library/Application Support/Qoder
+//   'qoder-cn'  ~/.qoder-cn      ~/Library/Application Support/QoderCN
+//
+// Verified against Qoder CLI 1.1.42 (both editions are one bundle branded via
+// QODERCLI_SITE) and IDE 1.28.0 product.json / extension code on 2026-09-04.
+
+const DB_RELATIVE = join('SharedClientCache', 'cache', 'db', 'local.db');
+
+export const QODER_EDITIONS = {
+  qoder: {
+    source: 'qoder',
+    label: 'Qoder',
+    cliDirName: '.qoder',
+    cliEnv: 'QODER_CONFIG_DIR',
+    ideDirName: 'Qoder',
+    ideHomeEnv: 'QODER_HOME',
+    testProjectsEnv: 'VIBE_USAGE_QODER_PROJECTS',
+    testDbEnv: 'VIBE_USAGE_QODER_DB',
+  },
+  'qoder-cn': {
+    source: 'qoder-cn',
+    label: 'Qoder CN',
+    cliDirName: '.qoder-cn',
+    cliEnv: 'QODERCN_CONFIG_DIR',
+    ideDirName: 'QoderCN',
+    ideHomeEnv: 'QODER_CN_HOME',
+    testProjectsEnv: 'VIBE_USAGE_QODER_CN_PROJECTS',
+    testDbEnv: 'VIBE_USAGE_QODER_CN_DB',
+  },
+};
+
+function expandHome(p) {
+  if (!p) return p;
+  return p.startsWith('~') ? join(homedir(), p.slice(1)) : p;
+}
+
+/** CLI/app transcript root: <configDir>/projects. Honors Qoder's own config-dir env. */
+export function getQoderProjectsDir(edition) {
+  const e = QODER_EDITIONS[edition];
+  const test = process.env[e.testProjectsEnv]?.trim();
+  if (test) return expandHome(test);
+  const cfg = process.env[e.cliEnv]?.trim();
+  const root = cfg ? expandHome(cfg).replace(/[/\\]+$/, '') : join(homedir(), e.cliDirName);
+  return join(root, 'projects');
+}
+
+/** IDE SQLite store. Honors QODER_HOME / QODER_CN_HOME like Qoder's own language server. */
+export function getQoderDbPath(edition) {
+  const e = QODER_EDITIONS[edition];
+  const test = process.env[e.testDbEnv]?.trim();
+  if (test) return expandHome(test);
+  const home = process.env[e.ideHomeEnv]?.trim();
+  if (home) return join(expandHome(home), 'cache', 'db', 'local.db');
+  let root;
+  if (process.platform === 'darwin') {
+    root = join(homedir(), 'Library', 'Application Support', e.ideDirName);
+  } else if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+    root = join(appData, e.ideDirName);
+  } else {
+    const xdg = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+    root = join(xdg, e.ideDirName);
+  }
+  return join(root, DB_RELATIVE);
+}
+
+/**
+ * Installed-detection for tools.js. `~/.qoder` alone proves nothing — the IDE
+ * also uses it (product.json dataFolderName) for extensions — so look for the
+ * transcript directory or the IDE database specifically.
+ */
+export function findQoderDataDirs(edition) {
+  return [getQoderProjectsDir(edition), getQoderDbPath(edition)].filter(existsSync);
+}

package/src/tools.js

@@ -13,6 +13,7 @@ import {
 import { findClineDataDirs } from './cline-roots.js';
 import { findCraftDataDirs } from './craft-roots.js';
 import { findOmpDataDirs, findPiDataDirs } from './pi-roots.js';
+import { findQoderDataDirs, getQoderProjectsDir } from './qoder-roots.js';
 import { findWorkbuddyDataDirs } from './workbuddy-roots.js';
 
 export function getAlmaDbPath(env = process.env, platform = process.platform, home = homedir()) {
@@ -323,6 +324,20 @@ export const TOOLS = [
       findPiDataDirs(extraRootList(extraRoots?.['pi-coding-agent']))
     ),
   },
+  {
+    name: 'Qoder',
+    id: 'qoder',
+    // CLI + desktop app transcripts; the IDE's SharedClientCache/cache/db/local.db
+    // is detected too. `~/.qoder` alone is not proof (the IDE stores extensions there).
+    dataDir: getQoderProjectsDir('qoder'),
+    detectDataDirs: () => findQoderDataDirs('qoder'),
+  },
+  {
+    name: 'Qoder CN',
+    id: 'qoder-cn',
+    dataDir: getQoderProjectsDir('qoder-cn'),
+    detectDataDirs: () => findQoderDataDirs('qoder-cn'),
+  },
   {
     name: 'Qwen Code',
     id: 'qwen-code',