@tokscale/cli 1.0.17 → 1.0.19

package/src/sessions/gemini.ts

@@ -1,108 +0,0 @@
-/**
- * Gemini CLI session parser
- * Reads from ~/.gemini/tmp/{projectHash}/chats/session-*.json
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { createUnifiedMessage, type UnifiedMessage, type TokenBreakdown } from "./types.js";
-
-interface GeminiMessage {
-  id: string;
-  timestamp: string;
-  type: "user" | "gemini";
-  content: string;
-  tokens?: {
-    input: number;
-    output: number;
-    cached: number;
-    thoughts: number;
-    tool: number;
-    total: number;
-  };
-  model?: string;
-}
-
-interface GeminiSession {
-  sessionId: string;
-  projectHash: string;
-  startTime: string;
-  lastUpdated: string;
-  messages: GeminiMessage[];
-}
-
-export function getGeminiBasePath(): string {
-  return path.join(os.homedir(), ".gemini");
-}
-
-export function parseGeminiMessages(): UnifiedMessage[] {
-  const basePath = getGeminiBasePath();
-  const tmpPath = path.join(basePath, "tmp");
-
-  if (!fs.existsSync(tmpPath)) {
-    return [];
-  }
-
-  const messages: UnifiedMessage[] = [];
-
-  try {
-    // Find all project directories
-    const projectDirs = fs
-      .readdirSync(tmpPath, { withFileTypes: true })
-      .filter((d) => d.isDirectory())
-      .map((d) => path.join(tmpPath, d.name));
-
-    for (const projectDir of projectDirs) {
-      const chatsDir = path.join(projectDir, "chats");
-      if (!fs.existsSync(chatsDir)) continue;
-
-      // Find all session JSON files
-      const sessionFiles = fs
-        .readdirSync(chatsDir)
-        .filter((f) => f.startsWith("session-") && f.endsWith(".json"));
-
-      for (const sessionFile of sessionFiles) {
-        try {
-          const content = fs.readFileSync(path.join(chatsDir, sessionFile), "utf-8");
-          const session = JSON.parse(content) as GeminiSession;
-
-          for (const msg of session.messages) {
-            // Only process gemini messages with token data and timestamp
-            if (msg.type !== "gemini" || !msg.tokens || !msg.model || !msg.timestamp) continue;
-
-            const timestamp = new Date(msg.timestamp).getTime();
-
-            // Skip invalid timestamps
-            if (isNaN(timestamp)) continue;
-
-            const tokens: TokenBreakdown = {
-              input: msg.tokens.input || 0,
-              output: msg.tokens.output || 0,
-              cacheRead: msg.tokens.cached || 0,
-              cacheWrite: 0, // Gemini doesn't track cache write
-              reasoning: msg.tokens.thoughts || 0,
-            };
-
-            messages.push(
-              createUnifiedMessage(
-                "gemini",
-                msg.model,
-                "google",
-                session.sessionId,
-                timestamp,
-                tokens
-              )
-            );
-          }
-        } catch {
-          // Skip malformed files
-        }
-      }
-    }
-  } catch {
-    // Skip inaccessible directories
-  }
-
-  return messages;
-}

package/src/sessions/index.ts

@@ -1,126 +0,0 @@
-/**
- * Session parsers for different AI coding assistant formats
- *
- * This module provides TypeScript fallback parsers that match the Rust
- * implementations in packages/core/src/sessions/. Used when native module
- * is not available.
- */
-
-export * from "./types.js";
-export { parseOpenCodeMessages, getOpenCodeStoragePath } from "./opencode.js";
-export { parseClaudeCodeMessages, getClaudeCodeProjectsPath } from "./claudecode.js";
-export { parseCodexMessages, getCodexSessionsPath } from "./codex.js";
-export { parseGeminiMessages, getGeminiBasePath } from "./gemini.js";
-
-import type { UnifiedMessage, SourceType } from "./types.js";
-import { parseOpenCodeMessages } from "./opencode.js";
-import { parseClaudeCodeMessages } from "./claudecode.js";
-import { parseCodexMessages } from "./codex.js";
-import { parseGeminiMessages } from "./gemini.js";
-
-export interface ParsedMessages {
-  messages: UnifiedMessage[];
-  opencodeCount: number;
-  claudeCount: number;
-  codexCount: number;
-  geminiCount: number;
-  processingTimeMs: number;
-}
-
-export interface ParseOptions {
-  sources?: SourceType[];
-  since?: string;
-  until?: string;
-  year?: string;
-}
-
-/**
- * Check if a message date is within the filter range
- */
-function isDateInRange(date: string, since?: string, until?: string, year?: string): boolean {
-  // Year filter
-  if (year && !date.startsWith(year)) {
-    return false;
-  }
-
-  // Since filter
-  if (since && date < since) {
-    return false;
-  }
-
-  // Until filter
-  if (until && date > until) {
-    return false;
-  }
-
-  return true;
-}
-
-/**
- * Parse all local session sources using TypeScript fallback parsers
- */
-export function parseLocalSources(options: ParseOptions = {}): ParsedMessages {
-  const startTime = performance.now();
-  const sources = options.sources;
-
-  const allMessages: UnifiedMessage[] = [];
-  let opencodeCount = 0;
-  let claudeCount = 0;
-  let codexCount = 0;
-  let geminiCount = 0;
-
-  // Parse OpenCode
-  if (!sources || sources.includes("opencode")) {
-    const messages = parseOpenCodeMessages();
-    for (const msg of messages) {
-      if (isDateInRange(msg.date, options.since, options.until, options.year)) {
-        allMessages.push(msg);
-        opencodeCount++;
-      }
-    }
-  }
-
-  // Parse Claude Code
-  if (!sources || sources.includes("claude")) {
-    const messages = parseClaudeCodeMessages();
-    for (const msg of messages) {
-      if (isDateInRange(msg.date, options.since, options.until, options.year)) {
-        allMessages.push(msg);
-        claudeCount++;
-      }
-    }
-  }
-
-  // Parse Codex
-  if (!sources || sources.includes("codex")) {
-    const messages = parseCodexMessages();
-    for (const msg of messages) {
-      if (isDateInRange(msg.date, options.since, options.until, options.year)) {
-        allMessages.push(msg);
-        codexCount++;
-      }
-    }
-  }
-
-  // Parse Gemini
-  if (!sources || sources.includes("gemini")) {
-    const messages = parseGeminiMessages();
-    for (const msg of messages) {
-      if (isDateInRange(msg.date, options.since, options.until, options.year)) {
-        allMessages.push(msg);
-        geminiCount++;
-      }
-    }
-  }
-
-  const processingTimeMs = performance.now() - startTime;
-
-  return {
-    messages: allMessages,
-    opencodeCount,
-    claudeCount,
-    codexCount,
-    geminiCount,
-    processingTimeMs,
-  };
-}

package/src/sessions/opencode.ts

@@ -1,117 +0,0 @@
-/**
- * OpenCode session parser
- * Reads from ~/.local/share/opencode/storage/message/
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { createUnifiedMessage, type UnifiedMessage, type TokenBreakdown } from "./types.js";
-
-interface OpenCodeMessageFile {
-  id: string;
-  sessionID: string;
-  role: "assistant" | "user";
-  modelID?: string;
-  providerID?: string;
-  cost: number;
-  tokens?: {
-    input: number;
-    output: number;
-    reasoning: number;
-    cache: {
-      read: number;
-      write: number;
-    };
-  };
-  time: {
-    created: number;
-    completed?: number;
-  };
-  agent?: string;
-  mode?: string;
-}
-
-export function normalizeAgentName(agent: string): string {
-  const agentLower = agent.toLowerCase();
-
-  if (agentLower.includes("plan")) {
-    if (agentLower.includes("omo") || agentLower.includes("sisyphus")) {
-      return "Planner-Sisyphus";
-    }
-    return agent;
-  }
-
-  if (agentLower === "omo" || agentLower === "sisyphus") {
-    return "Sisyphus";
-  }
-
-  return agent;
-}
-
-export function getOpenCodeStoragePath(): string {
-  const dataHome = process.env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share");
-  return path.join(dataHome, "opencode", "storage");
-}
-
-export function parseOpenCodeMessages(): UnifiedMessage[] {
-  const storagePath = getOpenCodeStoragePath();
-  const messagePath = path.join(storagePath, "message");
-
-  if (!fs.existsSync(messagePath)) {
-    return [];
-  }
-
-  const messages: UnifiedMessage[] = [];
-  
-  try {
-    const sessionDirs = fs
-      .readdirSync(messagePath)
-      .map((dir) => path.join(messagePath, dir))
-      .filter((dir) => fs.statSync(dir).isDirectory());
-
-    for (const sessionDir of sessionDirs) {
-      const sessionId = path.basename(sessionDir);
-      const files = fs.readdirSync(sessionDir).filter((f) => f.endsWith(".json"));
-
-      for (const file of files) {
-        try {
-          const content = fs.readFileSync(path.join(sessionDir, file), "utf-8");
-          const msg = JSON.parse(content) as OpenCodeMessageFile;
-
-          if (msg.role === "assistant" && msg.tokens && msg.modelID) {
-            const tokens: TokenBreakdown = {
-              input: msg.tokens.input || 0,
-              output: msg.tokens.output || 0,
-              cacheRead: msg.tokens.cache?.read || 0,
-              cacheWrite: msg.tokens.cache?.write || 0,
-              reasoning: msg.tokens.reasoning || 0,
-            };
-
-            const agentOrMode = msg.mode || msg.agent;
-            const agent = agentOrMode ? normalizeAgentName(agentOrMode) : undefined;
-
-            messages.push(
-              createUnifiedMessage(
-                "opencode",
-                msg.modelID,
-                msg.providerID || "unknown",
-                sessionId,
-                msg.time.created,
-                tokens,
-                msg.cost || 0,
-                agent
-              )
-            );
-          }
-        } catch {
-          // Skip malformed files
-        }
-      }
-    }
-  } catch {
-    // Skip inaccessible directories
-  }
-
-  return messages;
-}