@massu/core 0.1.1 → 0.1.2

package/src/__tests__/cost-tracker.test.ts

@@ -1,348 +0,0 @@
-// Copyright (c) 2026 Massu. All rights reserved.
-// Licensed under BSL 1.1 - see LICENSE file for details.
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import Database from 'better-sqlite3';
-import {
-  getCostToolDefinitions,
-  isCostTool,
-  extractTokenUsage,
-  calculateCost,
-  storeSessionCost,
-  backfillSessionCosts,
-  handleCostToolCall,
-  type TokenUsage,
-  type CostResult,
-} from '../cost-tracker.ts';
-import type { TranscriptEntry } from '../transcript-parser.ts';
-
-function createTestDb(): Database.Database {
-  const db = new Database(':memory:');
-  db.pragma('journal_mode = WAL');
-
-  db.exec(`
-    CREATE TABLE sessions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT UNIQUE NOT NULL,
-      started_at TEXT NOT NULL,
-      started_at_epoch INTEGER NOT NULL
-    );
-
-    CREATE TABLE session_costs (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL UNIQUE,
-      model TEXT,
-      input_tokens INTEGER NOT NULL DEFAULT 0,
-      output_tokens INTEGER NOT NULL DEFAULT 0,
-      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
-      cache_write_tokens INTEGER NOT NULL DEFAULT 0,
-      total_tokens INTEGER NOT NULL DEFAULT 0,
-      estimated_cost_usd REAL NOT NULL DEFAULT 0.0,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-
-    CREATE TABLE feature_costs (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      feature_key TEXT NOT NULL,
-      session_id TEXT NOT NULL,
-      tokens_used INTEGER NOT NULL DEFAULT 0,
-      estimated_cost_usd REAL NOT NULL DEFAULT 0.0,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-  `);
-
-  return db;
-}
-
-describe('cost-tracker', () => {
-  let db: Database.Database;
-
-  beforeEach(() => {
-    db = createTestDb();
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  describe('getCostToolDefinitions', () => {
-    it('should return tool definitions for cost tools', () => {
-      const defs = getCostToolDefinitions();
-      expect(defs.length).toBe(3);
-
-      const names = defs.map(d => d.name);
-      expect(names.some(n => n.includes('cost_session'))).toBe(true);
-      expect(names.some(n => n.includes('cost_trend'))).toBe(true);
-      expect(names.some(n => n.includes('cost_feature'))).toBe(true);
-
-      for (const def of defs) {
-        expect(def.name).toBeTruthy();
-        expect(def.description).toBeTruthy();
-        expect(def.inputSchema).toBeTruthy();
-        expect(def.inputSchema.type).toBe('object');
-      }
-    });
-  });
-
-  describe('isCostTool', () => {
-    it('should return true for cost tools', () => {
-      expect(isCostTool('massu_cost_session')).toBe(true);
-      expect(isCostTool('massu_cost_trend')).toBe(true);
-      expect(isCostTool('massu_cost_feature')).toBe(true);
-    });
-
-    it('should return false for non-cost tools', () => {
-      expect(isCostTool('massu_quality_score')).toBe(false);
-      expect(isCostTool('massu_audit_log')).toBe(false);
-      expect(isCostTool('random_tool')).toBe(false);
-    });
-
-    it('should handle base names without prefix', () => {
-      expect(isCostTool('cost_session')).toBe(true);
-      expect(isCostTool('cost_trend')).toBe(true);
-    });
-  });
-
-  describe('extractTokenUsage', () => {
-    it('should extract token usage from transcript entries', () => {
-      const entries: TranscriptEntry[] = [
-        {
-          type: 'assistant',
-          message: {
-            usage: {
-              input_tokens: 1000,
-              output_tokens: 500,
-              cache_read_input_tokens: 200,
-              cache_creation_input_tokens: 100,
-            },
-            model: 'claude-sonnet-4-5',
-          } as Record<string, unknown>,
-        } as TranscriptEntry,
-        {
-          type: 'assistant',
-          message: {
-            usage: {
-              input_tokens: 800,
-              output_tokens: 400,
-              cache_read_tokens: 50,
-              cache_write_tokens: 25,
-            },
-            model: 'claude-sonnet-4-5',
-          } as Record<string, unknown>,
-        } as TranscriptEntry,
-      ];
-
-      const usage = extractTokenUsage(entries);
-      expect(usage.inputTokens).toBe(1800);
-      expect(usage.outputTokens).toBe(900);
-      expect(usage.cacheReadTokens).toBe(250);
-      expect(usage.cacheWriteTokens).toBe(125);
-      expect(usage.model).toBe('claude-sonnet-4-5');
-    });
-
-    it('should return zero tokens for empty entries', () => {
-      const usage = extractTokenUsage([]);
-      expect(usage.inputTokens).toBe(0);
-      expect(usage.outputTokens).toBe(0);
-      expect(usage.cacheReadTokens).toBe(0);
-      expect(usage.cacheWriteTokens).toBe(0);
-      expect(usage.model).toBe('unknown');
-    });
-  });
-
-  describe('calculateCost', () => {
-    it('should calculate cost from token usage', () => {
-      const usage: TokenUsage = {
-        inputTokens: 1_000_000,
-        outputTokens: 500_000,
-        cacheReadTokens: 200_000,
-        cacheWriteTokens: 100_000,
-        model: 'claude-sonnet-4-5',
-      };
-
-      const cost = calculateCost(usage);
-
-      expect(cost.totalCost).toBeGreaterThan(0);
-      expect(cost.inputCost).toBeGreaterThan(0);
-      expect(cost.outputCost).toBeGreaterThan(0);
-      // Cache costs may be 0 if pricing doesn't include cache_read/write rates
-      expect(cost.cacheReadCost).toBeGreaterThanOrEqual(0);
-      expect(cost.cacheWriteCost).toBeGreaterThanOrEqual(0);
-      expect(cost.currency).toBe('USD');
-      expect(cost.totalCost).toBe(
-        cost.inputCost + cost.outputCost + cost.cacheReadCost + cost.cacheWriteCost
-      );
-    });
-
-    it('should use default pricing for unknown models', () => {
-      const usage: TokenUsage = {
-        inputTokens: 1_000_000,
-        outputTokens: 500_000,
-        cacheReadTokens: 0,
-        cacheWriteTokens: 0,
-        model: 'unknown-model',
-      };
-
-      const cost = calculateCost(usage);
-      expect(cost.totalCost).toBeGreaterThan(0);
-    });
-
-    it('should handle zero tokens', () => {
-      const usage: TokenUsage = {
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheReadTokens: 0,
-        cacheWriteTokens: 0,
-        model: 'claude-sonnet-4-5',
-      };
-
-      const cost = calculateCost(usage);
-      expect(cost.totalCost).toBe(0);
-      expect(cost.inputCost).toBe(0);
-      expect(cost.outputCost).toBe(0);
-    });
-  });
-
-  describe('storeSessionCost', () => {
-    it('should store session cost in database', () => {
-      const sessionId = 'test-session-1';
-      db.prepare('INSERT INTO sessions (session_id, started_at, started_at_epoch) VALUES (?, ?, ?)').run(
-        sessionId,
-        new Date().toISOString(),
-        Math.floor(Date.now() / 1000)
-      );
-
-      const usage: TokenUsage = {
-        inputTokens: 1000,
-        outputTokens: 500,
-        cacheReadTokens: 200,
-        cacheWriteTokens: 100,
-        model: 'claude-sonnet-4-5',
-      };
-
-      const cost: CostResult = {
-        totalCost: 0.015,
-        inputCost: 0.003,
-        outputCost: 0.0075,
-        cacheReadCost: 0.0006,
-        cacheWriteCost: 0.00375,
-        currency: 'USD',
-      };
-
-      storeSessionCost(db, sessionId, usage, cost);
-
-      const stored = db.prepare('SELECT * FROM session_costs WHERE session_id = ?').get(sessionId) as Record<string, unknown>;
-      expect(stored).toBeDefined();
-      expect(stored.session_id).toBe(sessionId);
-      expect(stored.model).toBe('claude-sonnet-4-5');
-      expect(stored.input_tokens).toBe(1000);
-      expect(stored.output_tokens).toBe(500);
-      expect(stored.cache_read_tokens).toBe(200);
-      expect(stored.cache_write_tokens).toBe(100);
-      expect(stored.total_tokens).toBe(1800);
-      expect(stored.estimated_cost_usd).toBe(0.015);
-    });
-  });
-
-  describe('backfillSessionCosts', () => {
-    it('should return count of sessions without cost data', () => {
-      const sessions = ['session-1', 'session-2', 'session-3'];
-      for (const sid of sessions) {
-        db.prepare('INSERT INTO sessions (session_id, started_at, started_at_epoch) VALUES (?, ?, ?)').run(
-          sid,
-          new Date().toISOString(),
-          Math.floor(Date.now() / 1000)
-        );
-      }
-
-      const count = backfillSessionCosts(db);
-      expect(count).toBe(3);
-    });
-
-    it('should not count sessions that already have cost data', () => {
-      const sessionId = 'session-with-cost';
-      db.prepare('INSERT INTO sessions (session_id, started_at, started_at_epoch) VALUES (?, ?, ?)').run(
-        sessionId,
-        new Date().toISOString(),
-        Math.floor(Date.now() / 1000)
-      );
-
-      const usage: TokenUsage = {
-        inputTokens: 100,
-        outputTokens: 50,
-        cacheReadTokens: 0,
-        cacheWriteTokens: 0,
-        model: 'claude-sonnet-4-5',
-      };
-
-      const cost: CostResult = {
-        totalCost: 0.001,
-        inputCost: 0.0003,
-        outputCost: 0.00075,
-        cacheReadCost: 0,
-        cacheWriteCost: 0,
-        currency: 'USD',
-      };
-
-      storeSessionCost(db, sessionId, usage, cost);
-
-      const count = backfillSessionCosts(db);
-      expect(count).toBe(0);
-    });
-  });
-
-  describe('handleCostToolCall', () => {
-    it('should handle cost_session tool call', () => {
-      const sessionId = 'test-session-2';
-      db.prepare('INSERT INTO sessions (session_id, started_at, started_at_epoch) VALUES (?, ?, ?)').run(
-        sessionId,
-        new Date().toISOString(),
-        Math.floor(Date.now() / 1000)
-      );
-
-      const usage: TokenUsage = {
-        inputTokens: 1000,
-        outputTokens: 500,
-        cacheReadTokens: 100,
-        cacheWriteTokens: 50,
-        model: 'claude-sonnet-4-5',
-      };
-
-      const cost: CostResult = {
-        totalCost: 0.01,
-        inputCost: 0.003,
-        outputCost: 0.0075,
-        cacheReadCost: 0.0003,
-        cacheWriteCost: 0.0001875,
-        currency: 'USD',
-      };
-
-      storeSessionCost(db, sessionId, usage, cost);
-
-      const result = handleCostToolCall('massu_cost_session', { session_id: sessionId }, db);
-
-      expect(result.content).toBeDefined();
-      expect(result.content.length).toBeGreaterThan(0);
-      expect(result.content[0].type).toBe('text');
-      const text = result.content[0].text;
-      expect(text).toContain('Session Cost');
-      expect(text).toContain('Token Usage');
-    });
-
-    it('should return error for missing session_id', () => {
-      const result = handleCostToolCall('massu_cost_session', {}, db);
-
-      expect(result.content).toBeDefined();
-      expect(result.content[0].type).toBe('text');
-      expect(result.content[0].text).toContain('Usage');
-    });
-
-    it('should handle unknown tool name', () => {
-      const result = handleCostToolCall('massu_unknown_cost_tool', {}, db);
-
-      expect(result.content).toBeDefined();
-      expect(result.content[0].type).toBe('text');
-      expect(result.content[0].text).toContain('Unknown cost tool');
-    });
-  });
-});

package/src/__tests__/db.test.ts

@@ -1,177 +0,0 @@
-// Copyright (c) 2026 Massu. All rights reserved.
-// Licensed under BSL 1.1 - see LICENSE file for details.
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import Database from 'better-sqlite3';
-import { isDataStale, updateBuildTimestamp } from '../db.ts';
-import { unlinkSync, existsSync } from 'fs';
-import { resolve } from 'path';
-
-const TEST_DATA_DB_PATH = resolve(__dirname, '../test-data-db.db');
-const TEST_CODEGRAPH_DB_PATH = resolve(__dirname, '../test-codegraph-db.db');
-
-function createTestDataDb(): Database.Database {
-  if (existsSync(TEST_DATA_DB_PATH)) {
-    unlinkSync(TEST_DATA_DB_PATH);
-  }
-
-  const db = new Database(TEST_DATA_DB_PATH);
-  db.pragma('journal_mode = WAL');
-  db.pragma('foreign_keys = ON');
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS massu_meta (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-  `);
-
-  return db;
-}
-
-function createTestCodeGraphDb(): Database.Database {
-  if (existsSync(TEST_CODEGRAPH_DB_PATH)) {
-    unlinkSync(TEST_CODEGRAPH_DB_PATH);
-  }
-
-  const db = new Database(TEST_CODEGRAPH_DB_PATH);
-  db.pragma('journal_mode = WAL');
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS files (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      path TEXT UNIQUE NOT NULL,
-      indexed_at INTEGER NOT NULL
-    );
-  `);
-
-  return db;
-}
-
-describe('Database Module', () => {
-  let dataDb: Database.Database;
-  let codegraphDb: Database.Database;
-
-  beforeEach(() => {
-    dataDb = createTestDataDb();
-    codegraphDb = createTestCodeGraphDb();
-  });
-
-  afterEach(() => {
-    dataDb.close();
-    codegraphDb.close();
-    if (existsSync(TEST_DATA_DB_PATH)) {
-      unlinkSync(TEST_DATA_DB_PATH);
-    }
-    if (existsSync(TEST_CODEGRAPH_DB_PATH)) {
-      unlinkSync(TEST_CODEGRAPH_DB_PATH);
-    }
-  });
-
-  describe('isDataStale', () => {
-    it('returns true when no last_build_time exists', () => {
-      codegraphDb.prepare(`INSERT INTO files (path, indexed_at) VALUES ('test.ts', ?)`).run(
-        Math.floor(Date.now() / 1000)
-      );
-
-      const stale = isDataStale(dataDb, codegraphDb);
-      expect(stale).toBe(true);
-    });
-
-    it('returns true when codegraph is newer than last build', () => {
-      const oldTime = new Date(Date.now() - 60000); // 1 minute ago
-      dataDb.prepare(`INSERT INTO massu_meta (key, value) VALUES ('last_build_time', ?)`).run(
-        oldTime.toISOString()
-      );
-
-      const newTimestamp = Math.floor(Date.now() / 1000); // Now
-      codegraphDb.prepare(`INSERT INTO files (path, indexed_at) VALUES ('test.ts', ?)`).run(newTimestamp);
-
-      const stale = isDataStale(dataDb, codegraphDb);
-      expect(stale).toBe(true);
-    });
-
-    it('returns false when data is up to date', () => {
-      const currentTime = Math.floor(Date.now() / 1000);
-      const pastTime = currentTime - 60; // 1 minute ago
-
-      codegraphDb.prepare(`INSERT INTO files (path, indexed_at) VALUES ('test.ts', ?)`).run(pastTime);
-
-      dataDb.prepare(`INSERT INTO massu_meta (key, value) VALUES ('last_build_time', ?)`).run(
-        new Date().toISOString()
-      );
-
-      const stale = isDataStale(dataDb, codegraphDb);
-      expect(stale).toBe(false);
-    });
-
-    it('returns true when no files in codegraph', () => {
-      dataDb.prepare(`INSERT INTO massu_meta (key, value) VALUES ('last_build_time', ?)`).run(
-        new Date().toISOString()
-      );
-
-      const stale = isDataStale(dataDb, codegraphDb);
-      expect(stale).toBe(true);
-    });
-  });
-
-  describe('updateBuildTimestamp', () => {
-    it('inserts last_build_time when not exists', () => {
-      updateBuildTimestamp(dataDb);
-
-      const result = dataDb.prepare(`SELECT value FROM massu_meta WHERE key = 'last_build_time'`).get() as { value: string } | undefined;
-      expect(result).toBeTruthy();
-      expect(result?.value).toBeTruthy();
-
-      const timestamp = new Date(result!.value);
-      expect(timestamp.getTime()).toBeGreaterThan(Date.now() - 5000); // Within last 5 seconds
-    });
-
-    it('updates last_build_time when exists', () => {
-      const oldTime = new Date(Date.now() - 60000).toISOString(); // 1 minute ago
-      dataDb.prepare(`INSERT INTO massu_meta (key, value) VALUES ('last_build_time', ?)`).run(oldTime);
-
-      updateBuildTimestamp(dataDb);
-
-      const result = dataDb.prepare(`SELECT value FROM massu_meta WHERE key = 'last_build_time'`).get() as { value: string };
-      expect(result.value).not.toBe(oldTime);
-
-      const timestamp = new Date(result.value);
-      expect(timestamp.getTime()).toBeGreaterThan(Date.now() - 5000); // Within last 5 seconds
-    });
-
-    it('stores timestamp as ISO string', () => {
-      updateBuildTimestamp(dataDb);
-
-      const result = dataDb.prepare(`SELECT value FROM massu_meta WHERE key = 'last_build_time'`).get() as { value: string };
-      expect(result.value).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/); // ISO format
-    });
-  });
-
-  describe('Data DB schema', () => {
-    it('creates massu_meta table', () => {
-      const tables = dataDb.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='massu_meta'`).all();
-      expect(tables.length).toBe(1);
-    });
-
-    it('massu_meta has correct columns', () => {
-      const columns = dataDb.prepare(`PRAGMA table_info(massu_meta)`).all() as { name: string; type: string }[];
-      const columnNames = columns.map(c => c.name);
-      expect(columnNames).toContain('key');
-      expect(columnNames).toContain('value');
-    });
-  });
-
-  describe('CodeGraph DB schema', () => {
-    it('creates files table', () => {
-      const tables = codegraphDb.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='files'`).all();
-      expect(tables.length).toBe(1);
-    });
-
-    it('files table has indexed_at column', () => {
-      const columns = codegraphDb.prepare(`PRAGMA table_info(files)`).all() as { name: string }[];
-      const columnNames = columns.map(c => c.name);
-      expect(columnNames).toContain('indexed_at');
-    });
-  });
-});