@poco-ai/tokenarena 0.2.0 → 0.2.2-beta.2

package/dist/index.js

@@ -211,6 +211,17 @@ function readFileSafe(filePath) {
     return null;
   }
 }
+function parseJsonl(content) {
+  const results = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      results.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return results;
+}
 function extractSessionId(filePath) {
   return basename(filePath, ".jsonl");
 }
@@ -1098,37 +1109,657 @@ var OpenClawParser = class {
 };
 registerParser(new OpenClawParser());
 
+// src/parsers/qwen-code.ts
+import { existsSync as existsSync8, readdirSync as readdirSync6 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join8 } from "path";
+var TOOL_ID = "qwen-code";
+var TOOL_NAME = "Qwen Code";
+var DEFAULT_DATA_DIR2 = join8(homedir7(), ".qwen", "tmp");
+function createToolDefinition(dataDir) {
+  return {
+    id: TOOL_ID,
+    name: TOOL_NAME,
+    dataDir
+  };
+}
+function toSafeNumber(value) {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}
+function getPathLeaf2(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
+  const leaf = normalized.split("/").filter(Boolean).pop();
+  return leaf || "unknown";
+}
+function normalizeForPrefix(value) {
+  return value.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function findSessionFiles2(baseDir) {
+  const results = [];
+  if (!existsSync8(baseDir)) return results;
+  try {
+    for (const entry of readdirSync6(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const chatsDir = join8(baseDir, entry.name, "chats");
+      if (!existsSync8(chatsDir)) continue;
+      try {
+        for (const file of readdirSync6(chatsDir)) {
+          if (file.endsWith(".jsonl")) {
+            results.push(join8(chatsDir, file));
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return results;
+  }
+  return results;
+}
+function resolveQwenProject(cwd, filePath, dataDir = DEFAULT_DATA_DIR2) {
+  if (cwd) {
+    return getPathLeaf2(cwd);
+  }
+  const normalizedFilePath = normalizeForPrefix(filePath);
+  const normalizedDataDir = normalizeForPrefix(dataDir);
+  const prefix = `${normalizedDataDir}/`;
+  if (!normalizedFilePath.startsWith(prefix)) {
+    return "unknown";
+  }
+  const relativePath = normalizedFilePath.slice(prefix.length);
+  const projectId = relativePath.split("/")[0];
+  return projectId || "unknown";
+}
+var QwenCodeParser = class {
+  constructor(dataDir = DEFAULT_DATA_DIR2) {
+    this.dataDir = dataDir;
+    this.tool = createToolDefinition(dataDir);
+  }
+  tool;
+  async parse() {
+    const sessionFiles = findSessionFiles2(this.dataDir);
+    if (sessionFiles.length === 0) {
+      return { buckets: [], sessions: [] };
+    }
+    const entries = [];
+    const sessionEvents = [];
+    const seenUuids = /* @__PURE__ */ new Set();
+    for (const filePath of sessionFiles) {
+      const content = readFileSafe(filePath);
+      if (!content) continue;
+      const sessionId = filePath;
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          if (!obj.timestamp) continue;
+          const timestamp = new Date(obj.timestamp);
+          if (Number.isNaN(timestamp.getTime())) continue;
+          const project = resolveQwenProject(obj.cwd, filePath, this.dataDir);
+          if (obj.type === "user" || obj.type === "assistant") {
+            sessionEvents.push({
+              sessionId,
+              source: TOOL_ID,
+              project,
+              timestamp,
+              role: obj.type
+            });
+          }
+          if (obj.type !== "assistant") continue;
+          const usage = obj.usageMetadata || obj.usage;
+          if (!usage) continue;
+          const totalInput = toSafeNumber(usage.promptTokenCount) || toSafeNumber(usage.input_tokens);
+          const totalOutput = toSafeNumber(usage.candidatesTokenCount) || toSafeNumber(usage.output_tokens);
+          const cachedTokens = toSafeNumber(usage.cachedContentTokenCount);
+          const reasoningTokens = toSafeNumber(usage.thoughtsTokenCount);
+          if (totalInput === 0 && totalOutput === 0 && cachedTokens === 0 && reasoningTokens === 0) {
+            continue;
+          }
+          if (obj.uuid) {
+            if (seenUuids.has(obj.uuid)) continue;
+            seenUuids.add(obj.uuid);
+          }
+          entries.push({
+            sessionId,
+            source: TOOL_ID,
+            model: obj.model || "unknown",
+            project,
+            timestamp,
+            inputTokens: Math.max(0, totalInput - cachedTokens),
+            outputTokens: Math.max(0, totalOutput - reasoningTokens),
+            reasoningTokens,
+            cachedTokens
+          });
+        } catch {
+        }
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  isInstalled() {
+    return existsSync8(this.dataDir);
+  }
+};
+registerParser(new QwenCodeParser());
+
+// src/parsers/kimi-code.ts
+import { existsSync as existsSync9, readdirSync as readdirSync7 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join9 } from "path";
+var TOOL_ID2 = "kimi-code";
+var TOOL_NAME2 = "Kimi Code";
+var DEFAULT_SESSIONS_DIR = join9(homedir8(), ".kimi", "sessions");
+var DEFAULT_CONFIG_PATH = join9(homedir8(), ".kimi", "kimi.json");
+var USER_EVENT_TYPES = /* @__PURE__ */ new Set(["UserMessage", "user_message", "Input"]);
+var ASSISTANT_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "AssistantMessage",
+  "assistant_message",
+  "Output",
+  "ModelOutput",
+  "AssistantOutput"
+]);
+function createToolDefinition2(dataDir) {
+  return {
+    id: TOOL_ID2,
+    name: TOOL_NAME2,
+    dataDir
+  };
+}
+function toSafeNumber2(value) {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}
+function getPathLeaf3(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
+  const leaf = normalized.split("/").filter(Boolean).pop();
+  return leaf || "unknown";
+}
+function findWireFiles(baseDir) {
+  const results = [];
+  if (!existsSync9(baseDir)) return results;
+  try {
+    for (const workDir of readdirSync7(baseDir, { withFileTypes: true })) {
+      if (!workDir.isDirectory()) continue;
+      const workDirPath = join9(baseDir, workDir.name);
+      try {
+        for (const session of readdirSync7(workDirPath, {
+          withFileTypes: true
+        })) {
+          if (!session.isDirectory()) continue;
+          const wireFile = join9(workDirPath, session.name, "wire.jsonl");
+          if (existsSync9(wireFile)) {
+            results.push({ filePath: wireFile, workDirHash: workDir.name });
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return results;
+  }
+  return results;
+}
+function parseTimestamp(value) {
+  if (value == null) return null;
+  const timestamp = new Date(value);
+  return Number.isNaN(timestamp.getTime()) ? null : timestamp;
+}
+function classifyKimiRole(type, payload) {
+  if (payload?.role === "user" || payload?.role === "assistant") {
+    return payload.role;
+  }
+  if (type && USER_EVENT_TYPES.has(type)) {
+    return "user";
+  }
+  if (type && ASSISTANT_EVENT_TYPES.has(type)) {
+    return "assistant";
+  }
+  if (type?.toLowerCase().includes("assistant")) {
+    return "assistant";
+  }
+  return null;
+}
+function loadProjectMap(configPath) {
+  const projectMap = /* @__PURE__ */ new Map();
+  const content = readFileSafe(configPath);
+  if (!content) return projectMap;
+  try {
+    const config = JSON.parse(content);
+    const workspaces = config.workspaces || config.projects || {};
+    for (const [hash, info] of Object.entries(workspaces)) {
+      const pathValue = typeof info === "string" ? info : info.path || info.dir || void 0;
+      if (!pathValue) continue;
+      projectMap.set(hash, getPathLeaf3(pathValue));
+    }
+  } catch {
+  }
+  return projectMap;
+}
+var KimiCodeParser = class {
+  tool;
+  sessionsDir;
+  configPath;
+  constructor(options = {}) {
+    this.sessionsDir = options.sessionsDir || DEFAULT_SESSIONS_DIR;
+    this.configPath = options.configPath || DEFAULT_CONFIG_PATH;
+    this.tool = createToolDefinition2(this.sessionsDir);
+  }
+  async parse() {
+    const wireFiles = findWireFiles(this.sessionsDir);
+    if (wireFiles.length === 0) {
+      return { buckets: [], sessions: [] };
+    }
+    const projectMap = loadProjectMap(this.configPath);
+    const entries = [];
+    const sessionEvents = [];
+    const seenMessageIds = /* @__PURE__ */ new Set();
+    for (const { filePath, workDirHash } of wireFiles) {
+      const content = readFileSafe(filePath);
+      if (!content) continue;
+      const sessionId = filePath;
+      const project = projectMap.get(workDirHash) || workDirHash;
+      let currentModel = "unknown";
+      let lastTimestampRaw;
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const payload = obj.payload;
+        if (!payload) continue;
+        if (payload.model) {
+          currentModel = payload.model;
+        }
+        const timestampValue = payload.timestamp ?? obj.timestamp ?? lastTimestampRaw;
+        const timestamp = parseTimestamp(timestampValue);
+        if (payload.timestamp != null) {
+          lastTimestampRaw = payload.timestamp;
+        } else if (obj.timestamp != null) {
+          lastTimestampRaw = obj.timestamp;
+        }
+        const role = classifyKimiRole(obj.type, payload);
+        if (role && timestamp) {
+          sessionEvents.push({
+            sessionId,
+            source: TOOL_ID2,
+            project,
+            timestamp,
+            role
+          });
+        }
+        if (obj.type !== "StatusUpdate") continue;
+        const tokenUsage = payload.token_usage;
+        if (!tokenUsage || !timestamp) continue;
+        const inputTokens = toSafeNumber2(tokenUsage.input_other);
+        const outputTokens = toSafeNumber2(tokenUsage.output);
+        const cachedTokens = toSafeNumber2(tokenUsage.input_cache_read);
+        const cacheCreateTokens = toSafeNumber2(tokenUsage.input_cache_creation);
+        if (inputTokens === 0 && outputTokens === 0 && cachedTokens === 0 && cacheCreateTokens === 0) {
+          continue;
+        }
+        if (payload.message_id) {
+          if (seenMessageIds.has(payload.message_id)) continue;
+          seenMessageIds.add(payload.message_id);
+        }
+        if (!role) {
+          sessionEvents.push({
+            sessionId,
+            source: TOOL_ID2,
+            project,
+            timestamp,
+            role: "assistant"
+          });
+        }
+        entries.push({
+          sessionId,
+          source: TOOL_ID2,
+          model: currentModel,
+          project,
+          timestamp,
+          inputTokens,
+          outputTokens,
+          reasoningTokens: 0,
+          cachedTokens
+        });
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  isInstalled() {
+    return existsSync9(this.sessionsDir);
+  }
+};
+registerParser(new KimiCodeParser());
+
+// src/parsers/droid.ts
+import { existsSync as existsSync10, readdirSync as readdirSync8 } from "fs";
+import { homedir as homedir9 } from "os";
+import { basename as basename4, dirname as dirname2, join as join10 } from "path";
+var TOOL_ID3 = "droid";
+var TOOL_NAME3 = "Droid";
+var DEFAULT_DATA_DIR3 = join10(homedir9(), ".factory", "sessions");
+function createToolDefinition3(dataDir) {
+  return {
+    id: TOOL_ID3,
+    name: TOOL_NAME3,
+    dataDir
+  };
+}
+function findSessionFiles3(dir) {
+  const results = [];
+  if (!existsSync10(dir)) return results;
+  try {
+    for (const entry of readdirSync8(dir, { withFileTypes: true })) {
+      const fullPath = join10(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findSessionFiles3(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl") && !entry.name.endsWith(".settings.json")) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function extractDroidProject(slug) {
+  const parts = slug.split("-").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : "unknown";
+}
+function toSafeNumber3(value) {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}
+var DroidParser = class {
+  constructor(dataDir = DEFAULT_DATA_DIR3) {
+    this.dataDir = dataDir;
+    this.tool = createToolDefinition3(dataDir);
+  }
+  tool;
+  async parse() {
+    const sessionFiles = findSessionFiles3(this.dataDir);
+    if (sessionFiles.length === 0) {
+      return { buckets: [], sessions: [] };
+    }
+    const entries = [];
+    const sessionEvents = [];
+    for (const filePath of sessionFiles) {
+      const sessionId = filePath;
+      const project = extractDroidProject(basename4(dirname2(filePath)));
+      let firstMessageTimestamp = null;
+      const content = readFileSafe(filePath);
+      if (!content) continue;
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (obj.type !== "message" || !obj.timestamp) continue;
+        const timestamp = new Date(obj.timestamp);
+        if (Number.isNaN(timestamp.getTime())) continue;
+        const role = obj.message?.role;
+        if (role !== "user" && role !== "assistant") continue;
+        if (firstMessageTimestamp === null) {
+          firstMessageTimestamp = timestamp;
+        }
+        sessionEvents.push({
+          sessionId,
+          source: TOOL_ID3,
+          project,
+          timestamp,
+          role
+        });
+      }
+      const settingsPath = join10(
+        dirname2(filePath),
+        `${basename4(filePath, ".jsonl")}.settings.json`
+      );
+      const settingsContent = readFileSafe(settingsPath);
+      if (!settingsContent || firstMessageTimestamp === null) continue;
+      let settings;
+      try {
+        settings = JSON.parse(settingsContent);
+      } catch {
+        continue;
+      }
+      const tokenUsage = settings.tokenUsage;
+      if (!tokenUsage) continue;
+      const cachedTokens = toSafeNumber3(tokenUsage.cacheReadTokens);
+      const reasoningTokens = toSafeNumber3(tokenUsage.thinkingTokens);
+      const inputTokens = Math.max(
+        0,
+        toSafeNumber3(tokenUsage.inputTokens) - cachedTokens
+      );
+      const outputTokens = Math.max(
+        0,
+        toSafeNumber3(tokenUsage.outputTokens) - reasoningTokens
+      );
+      if (inputTokens === 0 && outputTokens === 0 && cachedTokens === 0 && reasoningTokens === 0) {
+        continue;
+      }
+      entries.push({
+        sessionId,
+        source: TOOL_ID3,
+        model: settings.model || "unknown",
+        project,
+        timestamp: firstMessageTimestamp,
+        inputTokens,
+        outputTokens,
+        reasoningTokens,
+        cachedTokens
+      });
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  isInstalled() {
+    return existsSync10(this.dataDir);
+  }
+};
+registerParser(new DroidParser());
+
+// src/parsers/pi-coding-agent.ts
+import { existsSync as existsSync11 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join11 } from "path";
+var TOOL_ID4 = "pi-coding-agent";
+var TOOL_NAME4 = "pi";
+var DEFAULT_SESSIONS_DIR2 = join11(homedir10(), ".pi", "agent", "sessions");
+function createToolDefinition4(dataDir) {
+  return {
+    id: TOOL_ID4,
+    name: TOOL_NAME4,
+    dataDir
+  };
+}
+function toSafeNumber4(value) {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}
+function getPathLeaf4(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
+  const leaf = normalized.split("/").filter(Boolean).pop();
+  return leaf || "unknown";
+}
+function normalizeForPrefix2(value) {
+  return value.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function getUsageNumber(usage, ...keys) {
+  for (const key of keys) {
+    const value = usage[key];
+    const numberValue = toSafeNumber4(value);
+    if (numberValue > 0) {
+      return numberValue;
+    }
+  }
+  return 0;
+}
+function extractPiProjectFromCwd(cwd) {
+  return getPathLeaf4(cwd);
+}
+function extractPiProjectFromDir(filePath, sessionsDir = DEFAULT_SESSIONS_DIR2) {
+  const normalizedFilePath = normalizeForPrefix2(filePath);
+  const normalizedSessionsDir = normalizeForPrefix2(sessionsDir);
+  const prefix = `${normalizedSessionsDir}/`;
+  if (!normalizedFilePath.startsWith(prefix)) {
+    return "unknown";
+  }
+  const relativePath = normalizedFilePath.slice(prefix.length);
+  const firstSegment = relativePath.split("/")[0];
+  if (!firstSegment) {
+    return "unknown";
+  }
+  try {
+    const decoded = decodeURIComponent(firstSegment);
+    if (decoded.includes("/") || decoded.includes("\\")) {
+      return getPathLeaf4(decoded);
+    }
+  } catch {
+  }
+  const slugParts = firstSegment.split("-").filter(Boolean);
+  return slugParts.length > 0 ? slugParts[slugParts.length - 1] : "unknown";
+}
+var PiCodingAgentParser = class {
+  constructor(sessionsDir = DEFAULT_SESSIONS_DIR2) {
+    this.sessionsDir = sessionsDir;
+    this.tool = createToolDefinition4(sessionsDir);
+  }
+  tool;
+  async parse() {
+    const sessionFiles = findJsonlFiles(this.sessionsDir);
+    if (sessionFiles.length === 0) {
+      return { buckets: [], sessions: [] };
+    }
+    const entries = [];
+    const sessionEvents = [];
+    const seenEntryIds = /* @__PURE__ */ new Set();
+    for (const filePath of sessionFiles) {
+      const content = readFileSafe(filePath);
+      if (!content) continue;
+      const rows = parseJsonl(content);
+      if (rows.length === 0) continue;
+      let sessionId = filePath;
+      let project = extractPiProjectFromDir(filePath, this.sessionsDir);
+      for (const row of rows) {
+        if (row.type !== "session") continue;
+        if (row.id) {
+          sessionId = row.id;
+        }
+        if (row.cwd) {
+          project = extractPiProjectFromCwd(row.cwd);
+        }
+        break;
+      }
+      for (const row of rows) {
+        if (row.type !== "message") continue;
+        const message = row.message;
+        if (!message) continue;
+        const rawTimestamp = row.timestamp || message.timestamp;
+        if (!rawTimestamp) continue;
+        const timestamp = new Date(rawTimestamp);
+        if (Number.isNaN(timestamp.getTime())) continue;
+        if (message.role === "user" || message.role === "assistant") {
+          sessionEvents.push({
+            sessionId,
+            source: TOOL_ID4,
+            project,
+            timestamp,
+            role: message.role
+          });
+        }
+        if (message.role !== "assistant") continue;
+        const usage = message.usage;
+        if (!usage) continue;
+        const inputTokens = getUsageNumber(usage, "input", "inputTokens");
+        const outputTokens = getUsageNumber(usage, "output", "outputTokens");
+        const cachedTokens = getUsageNumber(
+          usage,
+          "cacheRead",
+          "cacheReadTokens",
+          "cache_read"
+        );
+        const reasoningTokens = getUsageNumber(
+          usage,
+          "reasoningOutputTokens",
+          "thinkingTokens",
+          "thoughts"
+        );
+        if (inputTokens === 0 && outputTokens === 0 && cachedTokens === 0 && reasoningTokens === 0) {
+          continue;
+        }
+        if (row.id) {
+          if (seenEntryIds.has(row.id)) continue;
+          seenEntryIds.add(row.id);
+        }
+        entries.push({
+          sessionId,
+          source: TOOL_ID4,
+          model: message.model || "unknown",
+          project,
+          timestamp,
+          inputTokens,
+          outputTokens,
+          reasoningTokens,
+          cachedTokens
+        });
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  isInstalled() {
+    return existsSync11(this.sessionsDir);
+  }
+};
+registerParser(new PiCodingAgentParser());
+
 // src/cli.ts
 import { Command, Option } from "commander";
 
 // src/infrastructure/config/manager.ts
 import { randomUUID } from "crypto";
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync12,
   mkdirSync,
   readFileSync as readFileSync6,
   unlinkSync,
   writeFileSync
 } from "fs";
-import { join as join9 } from "path";
+import { join as join13 } from "path";
 
 // src/infrastructure/xdg.ts
-import { homedir as homedir7 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join12 } from "path";
 function getConfigHome() {
-  return process.env.XDG_CONFIG_HOME || join8(homedir7(), ".config");
+  return process.env.XDG_CONFIG_HOME || join12(homedir11(), ".config");
 }
 function getStateHome() {
-  return process.env.XDG_STATE_HOME || join8(homedir7(), ".local", "state");
+  return process.env.XDG_STATE_HOME || join12(homedir11(), ".local", "state");
 }
 function getRuntimeDir() {
   return process.env.XDG_RUNTIME_DIR || getStateHome();
 }
 
 // src/infrastructure/config/manager.ts
-var CONFIG_DIR = join9(getConfigHome(), "tokenarena");
+var CONFIG_DIR = join13(getConfigHome(), "tokenarena");
 var isDev = process.env.TOKEN_ARENA_DEV === "1";
-var CONFIG_FILE = join9(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
+var CONFIG_FILE = join13(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
 var DEFAULT_API_URL = "https://token.poco-ai.com";
 var VALID_CONFIG_KEYS = [
   "apiKey",
@@ -1144,7 +1775,7 @@ function getConfigDir() {
   return CONFIG_DIR;
 }
 function loadConfig() {
-  if (!existsSync8(CONFIG_FILE)) return null;
+  if (!existsSync12(CONFIG_FILE)) return null;
   try {
     const raw = readFileSync6(CONFIG_FILE, "utf-8");
     const config = JSON.parse(raw);
@@ -1162,7 +1793,7 @@ function saveConfig(config) {
 `, "utf-8");
 }
 function deleteConfig() {
-  if (existsSync8(CONFIG_FILE)) {
+  if (existsSync12(CONFIG_FILE)) {
     unlinkSync(CONFIG_FILE);
   }
 }
@@ -2019,7 +2650,7 @@ var ApiClient = class {
 // src/infrastructure/runtime/lock.ts
 import {
   closeSync,
-  existsSync as existsSync9,
+  existsSync as existsSync13,
   openSync,
   readFileSync as readFileSync7,
   rmSync,
@@ -2028,22 +2659,22 @@ import {
 
 // src/infrastructure/runtime/paths.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join10 } from "path";
+import { join as join14 } from "path";
 var APP_NAME = "tokenarena";
 function getRuntimeDirPath() {
-  return join10(getRuntimeDir(), APP_NAME);
+  return join14(getRuntimeDir(), APP_NAME);
 }
 function getStateDir() {
-  return join10(getStateHome(), APP_NAME);
+  return join14(getStateHome(), APP_NAME);
 }
 function getSyncLockPath() {
-  return join10(getRuntimeDirPath(), "sync.lock");
+  return join14(getRuntimeDirPath(), "sync.lock");
 }
 function getSyncStatePath() {
-  return join10(getStateDir(), "status.json");
+  return join14(getStateDir(), "status.json");
 }
 function getUploadManifestPath() {
-  return join10(getStateDir(), "upload-manifest.json");
+  return join14(getStateDir(), "upload-manifest.json");
 }
 function ensureAppDirs() {
   mkdirSync2(getRuntimeDirPath(), { recursive: true });
@@ -2061,7 +2692,7 @@ function isProcessAlive(pid) {
   }
 }
 function readLockMetadata(lockPath) {
-  if (!existsSync9(lockPath)) {
+  if (!existsSync13(lockPath)) {
     return null;
   }
   try {
@@ -2135,13 +2766,13 @@ function describeExistingSyncLock() {
 }
 
 // src/infrastructure/runtime/state.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
 function getDefaultState() {
   return { status: "idle" };
 }
 function loadSyncState() {
   const path = getSyncStatePath();
-  if (!existsSync10(path)) {
+  if (!existsSync14(path)) {
     return getDefaultState();
   }
   try {
@@ -2202,7 +2833,7 @@ function markSyncFailed(source, error, status) {
 }
 
 // src/infrastructure/runtime/upload-manifest.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
 function isRecordOfStrings(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -2218,7 +2849,7 @@ function isUploadManifest(value) {
 }
 function loadUploadManifest() {
   const path = getUploadManifestPath();
-  if (!existsSync11(path)) {
+  if (!existsSync15(path)) {
     return null;
   }
   try {
@@ -2646,10 +3277,10 @@ View your dashboard at: ${apiUrl}/usage`);
 
 // src/commands/init.ts
 import { execFileSync as execFileSync2, spawn } from "child_process";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { appendFile, mkdir, readFile } from "fs/promises";
-import { homedir as homedir8, platform } from "os";
-import { dirname as dirname2, join as join11, posix, win32 } from "path";
+import { homedir as homedir12, platform } from "os";
+import { dirname as dirname3, join as join15, posix, win32 } from "path";
 function joinForPlatform(currentPlatform, ...parts) {
   return currentPlatform === "win32" ? win32.join(...parts) : posix.join(...parts);
 }
@@ -2693,7 +3324,7 @@ function resolvePowerShellProfilePath() {
   const systemRoot = process.env.SYSTEMROOT || "C:\\Windows";
   const candidates = [
     "pwsh.exe",
-    join11(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+    join15(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
   ];
   for (const command of candidates) {
     try {
@@ -2722,8 +3353,8 @@ function resolvePowerShellProfilePath() {
 function resolveShellAliasSetup(options = {}) {
   const currentPlatform = options.currentPlatform ?? platform();
   const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? homedir8();
-  const pathExists = options.exists ?? existsSync12;
+  const homeDir = options.homeDir ?? homedir12();
+  const pathExists = options.exists ?? existsSync16;
   const shellFromEnv = env.SHELL ? basenameLikeShell(env.SHELL).toLowerCase() : "";
   const shellName = shellFromEnv || (currentPlatform === "win32" ? "powershell" : "");
   const aliasName = "ta";
@@ -2894,9 +3525,9 @@ async function setupShellAlias() {
     return;
   }
   try {
-    await mkdir(dirname2(setup.configFile), { recursive: true });
+    await mkdir(dirname3(setup.configFile), { recursive: true });
     let existingContent = "";
-    if (existsSync12(setup.configFile)) {
+    if (existsSync16(setup.configFile)) {
       existingContent = await readFile(setup.configFile, "utf-8");
     }
     const normalizedContent = existingContent.toLowerCase();
@@ -3089,8 +3720,8 @@ async function runSyncCommand(opts = {}) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir9, platform as platform2 } from "os";
+import { existsSync as existsSync17, readFileSync as readFileSync10, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir13, platform as platform2 } from "os";
 function removeShellAlias() {
   const shell = process.env.SHELL;
   if (!shell) return;
@@ -3099,22 +3730,22 @@ function removeShellAlias() {
   let configFile;
   switch (shellName) {
     case "zsh":
-      configFile = `${homedir9()}/.zshrc`;
+      configFile = `${homedir13()}/.zshrc`;
       break;
     case "bash":
-      if (platform2() === "darwin" && existsSync13(`${homedir9()}/.bash_profile`)) {
-        configFile = `${homedir9()}/.bash_profile`;
+      if (platform2() === "darwin" && existsSync17(`${homedir13()}/.bash_profile`)) {
+        configFile = `${homedir13()}/.bash_profile`;
       } else {
-        configFile = `${homedir9()}/.bashrc`;
+        configFile = `${homedir13()}/.bashrc`;
       }
       break;
     case "fish":
-      configFile = `${homedir9()}/.config/fish/config.fish`;
+      configFile = `${homedir13()}/.config/fish/config.fish`;
       break;
     default:
       return;
   }
-  if (!existsSync13(configFile)) return;
+  if (!existsSync17(configFile)) return;
   try {
     let content = readFileSync10(configFile, "utf-8");
     const aliasPatterns = [
@@ -3149,7 +3780,7 @@ function removeShellAlias() {
 async function runUninstall() {
   const configPath = getConfigPath();
   const configDir = getConfigDir();
-  if (!existsSync13(configPath)) {
+  if (!existsSync17(configPath)) {
     logger.info(formatHeader("\u5378\u8F7D TokenArena"));
     logger.info(formatBullet("\u672A\u53D1\u73B0\u672C\u5730\u914D\u7F6E\uFF0C\u65E0\u9700\u5378\u8F7D\u3002"));
     return;
@@ -3178,7 +3809,7 @@ async function runUninstall() {
   deleteConfig();
   logger.info(formatSection("\u6267\u884C\u7ED3\u679C"));
   logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u6587\u4EF6\u3002", "success"));
-  if (existsSync13(configDir)) {
+  if (existsSync17(configDir)) {
     try {
       rmSync2(configDir, { recursive: false, force: true });
       logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u76EE\u5F55\u3002", "success"));
@@ -3186,12 +3817,12 @@ async function runUninstall() {
     }
   }
   const stateDir = getStateDir();
-  if (existsSync13(stateDir)) {
+  if (existsSync17(stateDir)) {
     rmSync2(stateDir, { recursive: true, force: true });
     logger.info(formatBullet("\u5DF2\u5220\u9664\u72B6\u6001\u6570\u636E\u3002", "success"));
   }
   const runtimeDir = getRuntimeDirPath();
-  if (existsSync13(runtimeDir)) {
+  if (existsSync17(runtimeDir)) {
     rmSync2(runtimeDir, { recursive: true, force: true });
     logger.info(formatBullet("\u5DF2\u5220\u9664\u8FD0\u884C\u65F6\u6570\u636E\u3002", "success"));
   }
@@ -3316,7 +3947,7 @@ async function runHome(program) {
 
 // src/infrastructure/runtime/cli-version.ts
 import { readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname3, join as join12 } from "path";
+import { dirname as dirname4, join as join16 } from "path";
 import { fileURLToPath } from "url";
 var FALLBACK_VERSION = "0.0.0";
 var cachedVersion;
@@ -3324,8 +3955,8 @@ function getCliVersion(metaUrl = import.meta.url) {
   if (cachedVersion) {
     return cachedVersion;
   }
-  const packageJsonPath = join12(
-    dirname3(fileURLToPath(metaUrl)),
+  const packageJsonPath = join16(
+    dirname4(fileURLToPath(metaUrl)),
     "..",
     "package.json"
   );
@@ -3380,7 +4011,7 @@ function createCli() {
 }
 
 // src/infrastructure/runtime/main-module.ts
-import { existsSync as existsSync14, realpathSync } from "fs";
+import { existsSync as existsSync18, realpathSync } from "fs";
 import { resolve } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
@@ -3391,7 +4022,7 @@ function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
   try {
     return realpathSync(argvEntry) === realpathSync(currentModulePath);
   } catch {
-    if (!existsSync14(argvEntry)) {
+    if (!existsSync18(argvEntry)) {
       return false;
     }
     return resolve(argvEntry) === resolve(currentModulePath);