@cognistore/mcp-server 1.2.2 → 1.4.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) {
@@ -509,11 +537,28 @@ var KnowledgeRepository = class {
       conditions.push(sql`${knowledgeEntries.scope} = ${filters.scope}`);
     return this.db.select().from(knowledgeEntries).where(and(...conditions)).orderBy(sql`${knowledgeEntries.createdAt} DESC`).limit(limit);
   }
-  async listTags() {
+  async listTags(opts = {}) {
+    const { from, to } = opts;
+    if (from && to) {
+      const result2 = await this.db.all(sql`SELECT DISTINCT value FROM knowledge_entries, json_each(knowledge_entries.tags)
+            WHERE knowledge_entries.type != 'system'
+              AND knowledge_entries.created_at >= ${from}
+              AND knowledge_entries.created_at < ${to}`);
+      return result2.map((r) => r.value);
+    }
     const result = await this.db.all(sql`SELECT DISTINCT value FROM knowledge_entries, json_each(knowledge_entries.tags) WHERE knowledge_entries.type != 'system'`);
     return result.map((r) => r.value);
   }
-  async topTags(limit = 10) {
+  async topTags(limit = 10, opts = {}) {
+    const { from, to } = opts;
+    if (from && to) {
+      const result2 = await this.db.all(sql`SELECT value as tag, COUNT(*) as count FROM knowledge_entries, json_each(knowledge_entries.tags)
+            WHERE knowledge_entries.type != 'system'
+              AND knowledge_entries.created_at >= ${from}
+              AND knowledge_entries.created_at < ${to}
+            GROUP BY value ORDER BY count DESC LIMIT ${limit}`);
+      return result2;
+    }
     const result = await this.db.all(sql`SELECT value as tag, COUNT(*) as count FROM knowledge_entries, json_each(knowledge_entries.tags) WHERE knowledge_entries.type != 'system' GROUP BY value ORDER BY count DESC LIMIT ${limit}`);
     return result;
   }
@@ -525,18 +570,30 @@ var KnowledgeRepository = class {
     const result = await this.db.all(sql`SELECT MAX(updated_at) as latest FROM knowledge_entries`);
     return result[0]?.latest ?? null;
   }
-  async countByType() {
+  async countByType(opts = {}) {
+    const { from, to } = opts;
+    const conditions = [ne(knowledgeEntries.type, "system")];
+    if (from && to) {
+      conditions.push(sql`${knowledgeEntries.createdAt} >= ${from}`);
+      conditions.push(sql`${knowledgeEntries.createdAt} < ${to}`);
+    }
     const results = await this.db.select({
       type: knowledgeEntries.type,
       count: sql`count(*)`
-    }).from(knowledgeEntries).where(ne(knowledgeEntries.type, "system")).groupBy(knowledgeEntries.type);
+    }).from(knowledgeEntries).where(and(...conditions)).groupBy(knowledgeEntries.type);
     return results.map((r) => ({ type: r.type, count: Number(r.count) }));
   }
-  async countByScope() {
+  async countByScope(opts = {}) {
+    const { from, to } = opts;
+    const conditions = [ne(knowledgeEntries.type, "system")];
+    if (from && to) {
+      conditions.push(sql`${knowledgeEntries.createdAt} >= ${from}`);
+      conditions.push(sql`${knowledgeEntries.createdAt} < ${to}`);
+    }
     const results = await this.db.select({
       scope: knowledgeEntries.scope,
       count: sql`count(*)`
-    }).from(knowledgeEntries).where(ne(knowledgeEntries.type, "system")).groupBy(knowledgeEntries.scope);
+    }).from(knowledgeEntries).where(and(...conditions)).groupBy(knowledgeEntries.scope);
     return results.map((r) => ({ scope: r.scope, count: Number(r.count) }));
   }
   async listAll() {
@@ -1015,11 +1072,11 @@ var KnowledgeService = class {
     const entries = await this.repository.listRecent(limit, filters);
     return entries.map((e) => this.toKnowledgeEntry(e));
   }
-  async topTags(limit = 10) {
-    return this.repository.topTags(limit);
+  async topTags(limit = 10, opts = {}) {
+    return this.repository.topTags(limit, opts);
   }
-  async listTags() {
-    return this.repository.listTags();
+  async listTags(opts = {}) {
+    return this.repository.listTags(opts);
   }
   async getStats() {
     const [count, byType, byScope, lastUpdatedAt] = await Promise.all([
@@ -1030,6 +1087,12 @@ var KnowledgeService = class {
     ]);
     return { total: count, byType, byScope, lastUpdatedAt };
   }
+  async countByType(opts = {}) {
+    return this.repository.countByType(opts);
+  }
+  async countByScope(opts = {}) {
+    return this.repository.countByScope(opts);
+  }
   // ─── Plans (separate entity) ────────────────────────────────
   async createPlan(input) {
     const { tasks, skipDedup, ...planInput } = input;
@@ -1288,6 +1351,502 @@ 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))) {
+        if (record) {
+          batch.push(record);
+          if (batch.length >= BATCH_SIZE)
+            flush();
+        }
+        offsets.set(filePath, { offset: byteOffset, mtime });
+        stats.scanned++;
+      }
+      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/adapters/copilot-cli.js
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync2, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { resolve as resolve4, basename as basename2 } from "path";
+var SOURCE2 = "copilot-cli";
+function recordId2(sessionId, model, occurredAt) {
+  const key = `${SOURCE2}|${sessionId ?? ""}|${model}|${occurredAt}`;
+  return createHash2("sha256").update(key).digest("hex").slice(0, 32);
+}
+function parseEventsFile(filePath) {
+  let raw;
+  try {
+    raw = readFileSync2(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  let cwd = null;
+  let sessionId = null;
+  let shutdown = null;
+  for (const line of raw.split("\n")) {
+    if (!line)
+      continue;
+    let evt;
+    try {
+      evt = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!evt || typeof evt !== "object")
+      continue;
+    if (evt.type === "session.start") {
+      const data = evt.data ?? {};
+      sessionId = data.sessionId ?? sessionId;
+      const ctx = data.context ?? {};
+      cwd = ctx.cwd ?? cwd;
+    } else if (evt.type === "session.shutdown") {
+      const data = evt.data ?? {};
+      const modelMetrics = data.modelMetrics;
+      if (!modelMetrics || typeof modelMetrics !== "object")
+        continue;
+      const perModel = [];
+      for (const [model, payload] of Object.entries(modelMetrics)) {
+        const usage = payload?.usage;
+        if (!usage || typeof usage !== "object")
+          continue;
+        perModel.push({
+          model,
+          inputTokens: Number(usage.inputTokens ?? 0) || 0,
+          outputTokens: Number(usage.outputTokens ?? 0) || 0,
+          cacheReadTokens: Number(usage.cacheReadTokens ?? 0) || 0,
+          cacheCreationTokens: Number(usage.cacheWriteTokens ?? 0) || 0
+        });
+      }
+      if (perModel.length === 0)
+        continue;
+      shutdown = {
+        occurredAt: evt.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId,
+        cwd,
+        perModel
+      };
+    }
+  }
+  return shutdown;
+}
+var CopilotCliAdapter = class {
+  name = SOURCE2;
+  sessionStateDir;
+  constructor(options = {}) {
+    this.sessionStateDir = options.sessionStateDir ?? resolve4(homedir3(), ".copilot", "session-state");
+  }
+  async *scan(getState) {
+    if (!existsSync3(this.sessionStateDir))
+      return;
+    let entries;
+    try {
+      entries = readdirSync3(this.sessionStateDir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const sessionDir = resolve4(this.sessionStateDir, entry);
+      let stat;
+      try {
+        stat = statSync2(sessionDir);
+      } catch {
+        continue;
+      }
+      if (!stat.isDirectory())
+        continue;
+      const filePath = resolve4(sessionDir, "events.jsonl");
+      let fstat;
+      try {
+        fstat = statSync2(filePath);
+      } catch {
+        continue;
+      }
+      const fileSize = fstat.size;
+      const mtime = fstat.mtime.toISOString();
+      const state = getState(filePath);
+      if (state && state.lastOffset >= fileSize)
+        continue;
+      const parsed = parseEventsFile(filePath);
+      if (!parsed) {
+        yield { record: null, filePath, byteOffset: fileSize, mtime };
+        continue;
+      }
+      const project = parsed.cwd ? basename2(parsed.cwd) : null;
+      for (const m of parsed.perModel) {
+        const record = {
+          id: recordId2(parsed.sessionId, m.model, parsed.occurredAt),
+          source: SOURCE2,
+          model: m.model,
+          project,
+          sessionId: parsed.sessionId,
+          messageId: null,
+          occurredAt: parsed.occurredAt,
+          inputTokens: m.inputTokens,
+          outputTokens: m.outputTokens,
+          cacheReadTokens: m.cacheReadTokens,
+          cacheCreationTokens: m.cacheCreationTokens
+        };
+        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(), new CopilotCliAdapter()]);
+  }
+  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;
@@ -1494,6 +2053,7 @@ var KnowledgeSDK = class {
   db = null;
   sqlite = null;
   service = null;
+  tokenService = null;
   ollamaClient;
   initialized = false;
   constructor(config) {
@@ -1523,6 +2083,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();
@@ -1605,22 +2167,38 @@ var KnowledgeSDK = class {
       throw this.wrapError(error, "Failed to list recent knowledge");
     }
   }
-  async getTopTags(limit = 10) {
+  async getTopTags(limit = 10, opts = {}) {
     this.ensureInitialized();
     try {
-      return await this.service.topTags(limit);
+      return await this.service.topTags(limit, opts);
     } catch (error) {
       throw this.wrapError(error, "Failed to get top tags");
     }
   }
-  async listTags() {
+  async listTags(opts = {}) {
     this.ensureInitialized();
     try {
-      return await this.service.listTags();
+      return await this.service.listTags(opts);
     } catch (error) {
       throw this.wrapError(error, "Failed to list tags");
     }
   }
+  async countByType(opts = {}) {
+    this.ensureInitialized();
+    try {
+      return await this.service.countByType(opts);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to count by type");
+    }
+  }
+  async countByScope(opts = {}) {
+    this.ensureInitialized();
+    try {
+      return await this.service.countByScope(opts);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to count by scope");
+    }
+  }
   async getStats() {
     this.ensureInitialized();
     try {
@@ -1781,6 +2359,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;
@@ -1857,6 +2444,7 @@ var KnowledgeSDK = class {
     }
     this.db = null;
     this.service = null;
+    this.tokenService = null;
   }
   /**
    * Detect if stored embeddings have different dimensions than config.
@@ -2082,6 +2670,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,6 +1,6 @@
 {
   "name": "@cognistore/mcp-server",
-  "version": "1.2.2",
+  "version": "1.4.0",
   "private": false,
   "type": "module",
   "description": "MCP server for CogniStore — integrates with Claude Code and GitHub Copilot",