@cognistore/mcp-server 1.1.0 → 1.3.0

package/dist/index.js

@@ -288,6 +288,34 @@ CREATE TABLE IF NOT EXISTS plan_tasks (
 );
 CREATE INDEX IF NOT EXISTS idx_plan_tasks_plan ON plan_tasks(plan_id);
 CREATE INDEX IF NOT EXISTS idx_plan_tasks_status ON plan_tasks(status);
+`,
+  "1.3.0": `
+CREATE TABLE IF NOT EXISTS token_usage (
+  id TEXT PRIMARY KEY,
+  source TEXT NOT NULL,
+  model TEXT NOT NULL,
+  project TEXT,
+  session_id TEXT,
+  message_id TEXT,
+  occurred_at TEXT NOT NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
+  scanned_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_token_usage_occurred ON token_usage (occurred_at);
+CREATE INDEX IF NOT EXISTS idx_token_usage_project ON token_usage (project);
+CREATE INDEX IF NOT EXISTS idx_token_usage_source_model ON token_usage (source, model);
+
+CREATE TABLE IF NOT EXISTS scan_state (
+  source TEXT NOT NULL,
+  file_path TEXT NOT NULL,
+  last_offset INTEGER NOT NULL DEFAULT 0,
+  last_mtime TEXT NOT NULL,
+  last_scanned_at TEXT NOT NULL,
+  PRIMARY KEY (source, file_path)
+);
 `
 };
 function runMigrations(sqlite, migrationsDir) {
@@ -407,6 +435,7 @@ function createPlansEmbeddingsTable(sqlite, dimensions = DEFAULT_EMBEDDING_DIMEN
 
 // ../../packages/core/dist/repositories/knowledge.repository.js
 import { eq, ne, sql, and, or, isNull } from "drizzle-orm";
+var OPERATIONS_RETENTION_DAYS = 30;
 var KnowledgeRepository = class {
   db;
   sqlite;
@@ -796,7 +825,7 @@ var KnowledgeRepository = class {
     return Object.entries(map).map(([date, counts]) => ({ date, ...counts }));
   }
   cleanupOldOperations() {
-    const cutoff = new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3).toISOString();
+    const cutoff = new Date(Date.now() - OPERATIONS_RETENTION_DAYS * 24 * 60 * 60 * 1e3).toISOString();
     return this.sqlite.prepare("DELETE FROM operations_log WHERE created_at < ?").run(cutoff).changes;
   }
   /**
@@ -1287,6 +1316,371 @@ var KnowledgeService = class {
   }
 };
 
+// ../../packages/core/dist/repositories/token-usage.repository.js
+var RANGE_CLAUSE = "occurred_at >= ? AND occurred_at <= ?";
+function applyOptionalFilters(filter) {
+  const params = [filter.from, filter.to];
+  let sql2 = RANGE_CLAUSE;
+  if (filter.source) {
+    sql2 += " AND source = ?";
+    params.push(filter.source);
+  }
+  if (filter.model) {
+    sql2 += " AND model = ?";
+    params.push(filter.model);
+  }
+  if (filter.project) {
+    sql2 += " AND project = ?";
+    params.push(filter.project);
+  }
+  return { sql: sql2, params };
+}
+var TokenUsageRepository = class {
+  sqlite;
+  constructor(sqlite) {
+    this.sqlite = sqlite;
+  }
+  // ─── Writes ────────────────────────────────────────────────────
+  /** Insert if new; never throw on conflict (deterministic id makes this idempotent). */
+  insertMany(records) {
+    if (records.length === 0)
+      return 0;
+    const stmt = this.sqlite.prepare(`
+      INSERT OR IGNORE INTO token_usage
+        (id, source, model, project, session_id, message_id, occurred_at,
+         input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, scanned_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const scannedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const tx = this.sqlite.transaction((rows) => {
+      let inserted = 0;
+      for (const r of rows) {
+        const info = stmt.run(r.id, r.source, r.model, r.project, r.sessionId, r.messageId, r.occurredAt, r.inputTokens, r.outputTokens, r.cacheReadTokens, r.cacheCreationTokens, scannedAt);
+        if (info.changes > 0)
+          inserted++;
+      }
+      return inserted;
+    });
+    return tx(records);
+  }
+  // ─── Scan state ────────────────────────────────────────────────
+  getScanState(source, filePath) {
+    const row = this.sqlite.prepare(`
+      SELECT source, file_path as filePath, last_offset as lastOffset, last_mtime as lastMtime
+      FROM scan_state WHERE source = ? AND file_path = ?
+    `).get(source, filePath);
+    return row;
+  }
+  upsertScanState(state) {
+    this.sqlite.prepare(`
+      INSERT INTO scan_state (source, file_path, last_offset, last_mtime, last_scanned_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(source, file_path) DO UPDATE SET
+        last_offset = excluded.last_offset,
+        last_mtime = excluded.last_mtime,
+        last_scanned_at = excluded.last_scanned_at
+    `).run(state.source, state.filePath, state.lastOffset, state.lastMtime, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  // ─── Aggregations ──────────────────────────────────────────────
+  totals(filter) {
+    const { sql: sql2, params } = applyOptionalFilters(filter);
+    const row = this.sqlite.prepare(`
+      SELECT
+        COALESCE(SUM(input_tokens), 0)          as inputTokens,
+        COALESCE(SUM(output_tokens), 0)         as outputTokens,
+        COALESCE(SUM(cache_read_tokens), 0)     as cacheReadTokens,
+        COALESCE(SUM(cache_creation_tokens), 0) as cacheCreationTokens
+      FROM token_usage WHERE ${sql2}
+    `).get(...params);
+    return row;
+  }
+  byDay(filter) {
+    const { sql: sql2, params } = applyOptionalFilters(filter);
+    const rows = this.sqlite.prepare(`
+      SELECT
+        date(occurred_at) as date,
+        COALESCE(SUM(input_tokens), 0)          as inputTokens,
+        COALESCE(SUM(output_tokens), 0)         as outputTokens,
+        COALESCE(SUM(cache_read_tokens), 0)     as cacheReadTokens,
+        COALESCE(SUM(cache_creation_tokens), 0) as cacheCreationTokens
+      FROM token_usage WHERE ${sql2}
+      GROUP BY date(occurred_at)
+      ORDER BY date(occurred_at)
+    `).all(...params);
+    return rows;
+  }
+  byModel(filter) {
+    const { sql: sql2, params } = applyOptionalFilters(filter);
+    const rows = this.sqlite.prepare(`
+      SELECT
+        model,
+        COALESCE(SUM(input_tokens), 0)          as inputTokens,
+        COALESCE(SUM(output_tokens), 0)         as outputTokens,
+        COALESCE(SUM(cache_read_tokens), 0)     as cacheReadTokens,
+        COALESCE(SUM(cache_creation_tokens), 0) as cacheCreationTokens,
+        COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_creation_tokens), 0) as totalTokens
+      FROM token_usage WHERE ${sql2}
+      GROUP BY model
+      ORDER BY totalTokens DESC
+    `).all(...params);
+    return rows;
+  }
+  byProject(filter) {
+    const { sql: sql2, params } = applyOptionalFilters(filter);
+    const rows = this.sqlite.prepare(`
+      SELECT
+        COALESCE(project, '(unknown)') as project,
+        COALESCE(SUM(input_tokens), 0)          as inputTokens,
+        COALESCE(SUM(output_tokens), 0)         as outputTokens,
+        COALESCE(SUM(cache_read_tokens), 0)     as cacheReadTokens,
+        COALESCE(SUM(cache_creation_tokens), 0) as cacheCreationTokens,
+        COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_creation_tokens), 0) as totalTokens
+      FROM token_usage WHERE ${sql2}
+      GROUP BY project
+      ORDER BY totalTokens DESC
+    `).all(...params);
+    return rows;
+  }
+  byHourDay(filter) {
+    const { sql: sql2, params } = applyOptionalFilters(filter);
+    const rows = this.sqlite.prepare(`
+      SELECT
+        CAST(strftime('%w', occurred_at) AS INTEGER) as dayOfWeek,
+        CAST(strftime('%H', occurred_at) AS INTEGER) as hour,
+        COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_creation_tokens), 0) as totalTokens
+      FROM token_usage WHERE ${sql2}
+      GROUP BY dayOfWeek, hour
+    `).all(...params);
+    return rows;
+  }
+  topSessions(filter, limit = 20) {
+    const { sql: sql2, params } = applyOptionalFilters(filter);
+    const rows = this.sqlite.prepare(`
+      SELECT
+        session_id as sessionId,
+        MAX(project) as project,
+        MAX(model) as model,
+        MIN(occurred_at) as startedAt,
+        MAX(occurred_at) as endedAt,
+        COUNT(*) as messageCount,
+        COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_creation_tokens), 0) as totalTokens
+      FROM token_usage WHERE ${sql2} AND session_id IS NOT NULL
+      GROUP BY session_id
+      ORDER BY totalTokens DESC
+      LIMIT ?
+    `).all(...params, limit);
+    return rows;
+  }
+};
+
+// ../../packages/core/dist/services/token-usage/scanner.js
+var BATCH_SIZE = 200;
+var TokenUsageScanner = class {
+  repo;
+  adapters;
+  constructor(repo, adapters) {
+    this.repo = repo;
+    this.adapters = adapters;
+  }
+  async scanAll() {
+    const bySource = {};
+    let totalInserted = 0;
+    let totalScanned = 0;
+    for (const adapter of this.adapters) {
+      const stats = { inserted: 0, scanned: 0 };
+      bySource[adapter.name] = stats;
+      let batch = [];
+      const offsets = /* @__PURE__ */ new Map();
+      const flush = () => {
+        if (batch.length === 0)
+          return;
+        stats.inserted += this.repo.insertMany(batch);
+        batch = [];
+      };
+      for await (const { record, filePath, byteOffset, mtime } of adapter.scan((fp) => this.repo.getScanState(adapter.name, fp))) {
+        batch.push(record);
+        offsets.set(filePath, { offset: byteOffset, mtime });
+        stats.scanned++;
+        if (batch.length >= BATCH_SIZE)
+          flush();
+      }
+      flush();
+      for (const [filePath, { offset, mtime }] of offsets) {
+        this.repo.upsertScanState({
+          source: adapter.name,
+          filePath,
+          lastOffset: offset,
+          lastMtime: mtime
+        });
+      }
+      totalInserted += stats.inserted;
+      totalScanned += stats.scanned;
+    }
+    return { inserted: totalInserted, scanned: totalScanned, bySource };
+  }
+};
+
+// ../../packages/core/dist/services/token-usage/adapters/claude-code.js
+import { createHash } from "crypto";
+import { existsSync as existsSync2, readdirSync as readdirSync2, statSync, openSync, readSync, closeSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { resolve as resolve3, basename } from "path";
+var SOURCE = "claude-code";
+function decodeProject(folderName) {
+  const trimmed = folderName.replace(/^-+/, "");
+  const parts = trimmed.split("-").filter(Boolean);
+  return parts[parts.length - 1] ?? folderName;
+}
+function recordId(sessionId, messageId, occurredAt) {
+  const key = `${SOURCE}|${sessionId ?? ""}|${messageId ?? ""}|${occurredAt}`;
+  return createHash("sha256").update(key).digest("hex").slice(0, 32);
+}
+function* readNewLines(filePath, fromOffset, fileSize) {
+  if (fromOffset >= fileSize)
+    return;
+  const fd = openSync(filePath, "r");
+  try {
+    const CHUNK = 64 * 1024;
+    const buf = Buffer.alloc(CHUNK);
+    let offset = fromOffset;
+    let pending = "";
+    while (offset < fileSize) {
+      const toRead = Math.min(CHUNK, fileSize - offset);
+      const bytesRead = readSync(fd, buf, 0, toRead, offset);
+      if (bytesRead === 0)
+        break;
+      pending += buf.subarray(0, bytesRead).toString("utf8");
+      offset += bytesRead;
+      let nl;
+      let pendingStart = 0;
+      while ((nl = pending.indexOf("\n", pendingStart)) !== -1) {
+        const line = pending.slice(pendingStart, nl);
+        pendingStart = nl + 1;
+        if (line.length > 0) {
+          yield { line, byteOffsetAfter: -1 };
+        }
+      }
+      pending = pending.slice(pendingStart);
+    }
+    void pending;
+  } finally {
+    closeSync(fd);
+  }
+}
+function parseUsageLine(line) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!obj || typeof obj !== "object")
+    return null;
+  const message = obj.message ?? obj;
+  const usage = message?.usage;
+  if (!usage || typeof usage !== "object")
+    return null;
+  const occurredAt = obj.timestamp ?? message?.timestamp;
+  if (!occurredAt)
+    return null;
+  const model = message?.model ?? "unknown";
+  const sessionId = obj.sessionId ?? message?.sessionId ?? null;
+  const messageId = message?.id ?? obj.uuid ?? null;
+  return {
+    source: SOURCE,
+    model,
+    sessionId,
+    messageId,
+    occurredAt,
+    inputTokens: Number(usage.input_tokens ?? 0) || 0,
+    outputTokens: Number(usage.output_tokens ?? 0) || 0,
+    cacheReadTokens: Number(usage.cache_read_input_tokens ?? 0) || 0,
+    cacheCreationTokens: Number(usage.cache_creation_input_tokens ?? 0) || 0
+  };
+}
+var ClaudeCodeAdapter = class {
+  name = SOURCE;
+  projectsDir;
+  constructor(options = {}) {
+    this.projectsDir = options.projectsDir ?? resolve3(homedir2(), ".claude", "projects");
+  }
+  async *scan(getState) {
+    if (!existsSync2(this.projectsDir))
+      return;
+    for (const folder of readdirSync2(this.projectsDir)) {
+      const projectDir = resolve3(this.projectsDir, folder);
+      let stat;
+      try {
+        stat = statSync(projectDir);
+      } catch {
+        continue;
+      }
+      if (!stat.isDirectory())
+        continue;
+      const project = decodeProject(basename(folder));
+      let files;
+      try {
+        files = readdirSync2(projectDir);
+      } catch {
+        continue;
+      }
+      for (const fileName of files) {
+        if (!fileName.endsWith(".jsonl"))
+          continue;
+        const filePath = resolve3(projectDir, fileName);
+        let fstat;
+        try {
+          fstat = statSync(filePath);
+        } catch {
+          continue;
+        }
+        const fileSize = fstat.size;
+        const mtime = fstat.mtime.toISOString();
+        const state = getState(filePath);
+        const fromOffset = state?.lastOffset ?? 0;
+        if (fromOffset >= fileSize)
+          continue;
+        for (const { line } of readNewLines(filePath, fromOffset, fileSize)) {
+          const parsed = parseUsageLine(line);
+          if (!parsed)
+            continue;
+          const record = {
+            ...parsed,
+            id: recordId(parsed.sessionId, parsed.messageId, parsed.occurredAt),
+            project
+          };
+          yield { record, filePath, byteOffset: fileSize, mtime };
+        }
+      }
+    }
+  }
+};
+
+// ../../packages/core/dist/services/token-usage/service.js
+var DEFAULT_TOP_SESSIONS = 20;
+var TokenUsageService = class {
+  repo;
+  scanner;
+  constructor(repo, adapters) {
+    this.repo = repo;
+    this.scanner = new TokenUsageScanner(repo, adapters ?? [new ClaudeCodeAdapter()]);
+  }
+  scan() {
+    return this.scanner.scanAll();
+  }
+  getAggregates(filter) {
+    const totals = this.repo.totals(filter);
+    const byDay = this.repo.byDay(filter);
+    const byModel = this.repo.byModel(filter);
+    const byProject = this.repo.byProject(filter);
+    const byHourDay = this.repo.byHourDay(filter);
+    const topSessions = this.repo.topSessions(filter, DEFAULT_TOP_SESSIONS);
+    const cacheDenom = totals.inputTokens + totals.cacheReadTokens + totals.cacheCreationTokens;
+    const cacheEfficiency = cacheDenom > 0 ? totals.cacheReadTokens / cacheDenom : 0;
+    return { totals, byDay, byModel, byProject, byHourDay, topSessions, cacheEfficiency };
+  }
+};
+
 // ../../packages/embeddings/dist/client.js
 var OllamaEmbeddingClient = class {
   host;
@@ -1493,6 +1887,7 @@ var KnowledgeSDK = class {
   db = null;
   sqlite = null;
   service = null;
+  tokenService = null;
   ollamaClient;
   initialized = false;
   constructor(config) {
@@ -1522,6 +1917,8 @@ var KnowledgeSDK = class {
       await this.detectAndMigrateDimensions();
       const repository = new KnowledgeRepository(this.db, this.sqlite);
       this.service = new KnowledgeService(repository, this.ollamaClient);
+      const tokenRepo = new TokenUsageRepository(this.sqlite);
+      this.tokenService = new TokenUsageService(tokenRepo);
       this.initialized = true;
     } catch (error) {
       await this.cleanup();
@@ -1780,6 +2177,15 @@ var KnowledgeSDK = class {
       return 0;
     return this.service.cleanupOldOperations();
   }
+  // ─── Token usage ────────────────────────────────────────────
+  async scanTokenUsage() {
+    this.ensureInitialized();
+    return this.tokenService.scan();
+  }
+  getTokenUsage(filter) {
+    this.ensureInitialized();
+    return this.tokenService.getAggregates(filter);
+  }
   cleanupCompletedPlanEmbeddings(maxAgeDays = 30) {
     if (!this.initialized || !this.service)
       return 0;
@@ -1856,6 +2262,7 @@ var KnowledgeSDK = class {
     }
     this.db = null;
     this.service = null;
+    this.tokenService = null;
   }
   /**
    * Detect if stored embeddings have different dimensions than config.
@@ -2081,6 +2488,32 @@ function createServer(sdk) {
       return { content: [{ type: "text", text: JSON.stringify(health, null, 2) }] };
     }
   );
+  server.tool(
+    "getTokenUsage",
+    "Aggregated token usage for AI coding tools (input/output/cache reads/cache writes) for a date range, optionally filtered by source, model, or project.",
+    {
+      from: z2.string().describe('ISO date \u2014 start of range (e.g. "2025-05-01T00:00:00Z")'),
+      to: z2.string().describe("ISO date \u2014 end of range"),
+      source: z2.string().optional().describe('Filter by source (e.g. "claude-code")'),
+      model: z2.string().optional().describe("Filter by model"),
+      project: z2.string().optional().describe("Filter by project (decoded cwd basename)")
+    },
+    READ_ONLY,
+    async (params) => {
+      try {
+        await sdk.scanTokenUsage();
+      } catch {
+      }
+      const result = sdk.getTokenUsage({
+        from: params.from,
+        to: params.to,
+        source: params.source,
+        model: params.model,
+        project: params.project
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
   server.tool(
     "createPlan",
     "Create a plan with tasks. Plan auto-activates when the first task starts. Returns planId \u2014 SAVE IT and pass to addKnowledge calls.",

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@cognistore/mcp-server",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "private": false,
   "type": "module",
   "description": "MCP server for CogniStore — integrates with Claude Code and GitHub Copilot",
-  "license": "BUSL-1.1",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Sithion/cognistore.git",