@cognistore/mcp-server 1.3.0 → 1.4.0

package/dist/index.js

@@ -537,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;
   }
@@ -553,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() {
@@ -1043,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([
@@ -1058,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;
@@ -1498,11 +1533,13 @@ var TokenUsageScanner = class {
         batch = [];
       };
       for await (const { record, filePath, byteOffset, mtime } of adapter.scan((fp) => this.repo.getScanState(adapter.name, fp))) {
-        batch.push(record);
+        if (record) {
+          batch.push(record);
+          if (batch.length >= BATCH_SIZE)
+            flush();
+        }
         offsets.set(filePath, { offset: byteOffset, mtime });
         stats.scanned++;
-        if (batch.length >= BATCH_SIZE)
-          flush();
       }
       flush();
       for (const [filePath, { offset, mtime }] of offsets) {
@@ -1656,6 +1693,135 @@ var ClaudeCodeAdapter = class {
   }
 };
 
+// ../../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 {
@@ -1663,7 +1829,7 @@ var TokenUsageService = class {
   scanner;
   constructor(repo, adapters) {
     this.repo = repo;
-    this.scanner = new TokenUsageScanner(repo, adapters ?? [new ClaudeCodeAdapter()]);
+    this.scanner = new TokenUsageScanner(repo, adapters ?? [new ClaudeCodeAdapter(), new CopilotCliAdapter()]);
   }
   scan() {
     return this.scanner.scanAll();
@@ -2001,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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognistore/mcp-server",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "private": false,
   "type": "module",
   "description": "MCP server for CogniStore — integrates with Claude Code and GitHub Copilot",