@massu/core 0.1.1 → 0.1.2

package/src/__tests__/adr-generator.test.ts

@@ -1,260 +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 {
-  getAdrToolDefinitions,
-  isAdrTool,
-  detectDecisionPatterns,
-  extractAlternatives,
-  storeDecision,
-  handleAdrToolCall,
-} from '../adr-generator.ts';
-
-function createTestDb(): Database.Database {
-  const db = new Database(':memory:');
-  db.exec(`
-    CREATE TABLE architecture_decisions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT,
-      title TEXT NOT NULL,
-      context TEXT,
-      decision TEXT NOT NULL,
-      status TEXT NOT NULL DEFAULT 'accepted' CHECK(status IN ('accepted', 'superseded', 'deprecated')),
-      alternatives TEXT,
-      consequences TEXT,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-  `);
-  return db;
-}
-
-describe('adr-generator', () => {
-  let db: Database.Database;
-
-  beforeEach(() => {
-    db = createTestDb();
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  describe('getAdrToolDefinitions', () => {
-    it('returns 3 tool definitions with correct names', () => {
-      const tools = getAdrToolDefinitions();
-      expect(tools).toHaveLength(3);
-      expect(tools.map(t => t.name.split('_').slice(-2).join('_'))).toEqual([
-        'adr_list',
-        'adr_detail',
-        'adr_create',
-      ]);
-    });
-
-    it('has required fields in tool definitions', () => {
-      const tools = getAdrToolDefinitions();
-      tools.forEach(tool => {
-        expect(tool.name).toBeTruthy();
-        expect(tool.description).toBeTruthy();
-        expect(tool.inputSchema).toBeDefined();
-        expect(tool.inputSchema.type).toBe('object');
-      });
-    });
-
-    it('adr_create requires title and decision', () => {
-      const tools = getAdrToolDefinitions();
-      const createTool = tools.find(t => t.name.endsWith('_adr_create'));
-      expect(createTool?.inputSchema.required).toEqual(['title', 'decision']);
-    });
-  });
-
-  describe('isAdrTool', () => {
-    it('returns true for ADR tool names', () => {
-      expect(isAdrTool('massu_adr_list')).toBe(true);
-      expect(isAdrTool('massu_adr_detail')).toBe(true);
-      expect(isAdrTool('massu_adr_create')).toBe(true);
-    });
-
-    it('returns false for non-ADR tool names', () => {
-      expect(isAdrTool('massu_security_score')).toBe(false);
-      expect(isAdrTool('massu_unknown')).toBe(false);
-      expect(isAdrTool('adr_list')).toBe(true); // base name without prefix
-    });
-  });
-
-  describe('detectDecisionPatterns', () => {
-    it('detects decision phrases in text', () => {
-      expect(detectDecisionPatterns('We chose Redis for caching')).toBe(true);
-      expect(detectDecisionPatterns('Decided to use TypeScript')).toBe(true);
-      expect(detectDecisionPatterns('switching to ESM modules')).toBe(true);
-      expect(detectDecisionPatterns('moving from CommonJS to ESM')).toBe(true);
-      expect(detectDecisionPatterns('going with Fastify')).toBe(true);
-    });
-
-    it('is case insensitive', () => {
-      expect(detectDecisionPatterns('DECIDED to refactor')).toBe(true);
-      expect(detectDecisionPatterns('Chose the new architecture')).toBe(true);
-    });
-
-    it('returns false when no decision pattern found', () => {
-      expect(detectDecisionPatterns('This is a regular sentence')).toBe(false);
-      expect(detectDecisionPatterns('No patterns here')).toBe(false);
-    });
-  });
-
-  describe('extractAlternatives', () => {
-    it('extracts alternatives from "X over Y" pattern', () => {
-      const result = extractAlternatives('We chose Redis over Memcached for caching');
-      // The regex captures from the last word before "over" to next word, so "chose Redis" and "Memcached for caching"
-      expect(result.length).toBeGreaterThan(0);
-      // Just verify the function works and returns alternatives
-      expect(result.some(alt => alt.includes('Redis'))).toBe(true);
-      expect(result.some(alt => alt.includes('Memcached'))).toBe(true);
-    });
-
-    it('extracts alternatives from "X instead of Y" pattern', () => {
-      const result = extractAlternatives('Use TypeScript instead of JavaScript');
-      expect(result.length).toBeGreaterThan(0);
-      expect(result.some(alt => alt.includes('TypeScript'))).toBe(true);
-      expect(result.some(alt => alt.includes('JavaScript'))).toBe(true);
-    });
-
-    it('extracts alternatives from "switching from X to Y" pattern', () => {
-      const result = extractAlternatives('switching from CommonJS to ESM modules');
-      expect(result.length).toBeGreaterThan(0);
-      expect(result.some(alt => alt.includes('ESM'))).toBe(true);
-      expect(result.some(alt => alt.includes('CommonJS'))).toBe(true);
-    });
-
-    it('returns unique alternatives only', () => {
-      const result = extractAlternatives('Redis over Memcached instead of Redis');
-      const unique = [...new Set(result)];
-      expect(result.length).toBe(unique.length);
-    });
-
-    it('returns empty array when no alternatives found', () => {
-      const result = extractAlternatives('This has no alternatives');
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('storeDecision', () => {
-    it('stores a decision and returns ID', () => {
-      const id = storeDecision(db, {
-        title: 'Use Redis for caching',
-        context: 'Need fast cache',
-        decision: 'Redis over Memcached',
-        alternatives: ['Redis', 'Memcached'],
-        consequences: 'Better performance',
-      });
-
-      expect(id).toBeGreaterThan(0);
-
-      const row = db.prepare('SELECT * FROM architecture_decisions WHERE id = ?').get(id) as Record<string, unknown>;
-      expect(row.title).toBe('Use Redis for caching');
-      expect(row.decision).toBe('Redis over Memcached');
-      expect(JSON.parse(row.alternatives as string)).toEqual(['Redis', 'Memcached']);
-    });
-
-    it('uses default status when not provided', () => {
-      const id = storeDecision(db, {
-        title: 'Test Decision',
-        context: 'Context',
-        decision: 'Decision text',
-        alternatives: [],
-        consequences: 'None',
-      });
-
-      const row = db.prepare('SELECT status FROM architecture_decisions WHERE id = ?').get(id) as { status: string };
-      expect(row.status).toBe('accepted');
-    });
-
-    it('accepts custom status', () => {
-      const id = storeDecision(db, {
-        title: 'Test Decision',
-        context: 'Context',
-        decision: 'Decision text',
-        alternatives: [],
-        consequences: 'None',
-        status: 'superseded',
-      });
-
-      const row = db.prepare('SELECT status FROM architecture_decisions WHERE id = ?').get(id) as { status: string };
-      expect(row.status).toBe('superseded');
-    });
-  });
-
-  describe('handleAdrToolCall', () => {
-    it('handles adr_list with no decisions', () => {
-      const result = handleAdrToolCall('massu_adr_list', {}, db);
-      expect(result.content[0].type).toBe('text');
-      const text = result.content[0].text;
-      expect(text).toContain('No architecture decisions found');
-    });
-
-    it('handles adr_list with decisions', () => {
-      storeDecision(db, {
-        title: 'Test Decision',
-        context: 'Context',
-        decision: 'Decision',
-        alternatives: [],
-        consequences: 'None',
-      });
-
-      const result = handleAdrToolCall('massu_adr_list', {}, db);
-      const text = result.content[0].text;
-      expect(text).toContain('Architecture Decisions (1)');
-      expect(text).toContain('Test Decision');
-    });
-
-    it('handles adr_detail for existing decision', () => {
-      const id = storeDecision(db, {
-        title: 'Test Decision',
-        context: 'Test Context',
-        decision: 'Test Decision Text',
-        alternatives: ['Option A', 'Option B'],
-        consequences: 'Test Consequences',
-      });
-
-      const result = handleAdrToolCall('massu_adr_detail', { id }, db);
-      const text = result.content[0].text;
-      expect(text).toContain(`ADR-${id}: Test Decision`);
-      expect(text).toContain('Test Context');
-      expect(text).toContain('Option A');
-      expect(text).toContain('Option B');
-      expect(text).toContain('Test Consequences');
-    });
-
-    it('handles adr_detail for non-existent decision', () => {
-      const result = handleAdrToolCall('massu_adr_detail', { id: 999 }, db);
-      const text = result.content[0].text;
-      expect(text).toContain('ADR #999 not found');
-    });
-
-    it('handles adr_create and extracts alternatives', () => {
-      const result = handleAdrToolCall('massu_adr_create', {
-        title: 'Use Redis',
-        decision: 'Redis over Memcached',
-        context: 'Need caching',
-        consequences: 'Better performance',
-      }, db);
-
-      const text = result.content[0].text;
-      expect(text).toContain('ADR-1 Created');
-      expect(text).toContain('Redis');
-      expect(text).toContain('Memcached');
-
-      const row = db.prepare('SELECT * FROM architecture_decisions WHERE id = 1').get() as Record<string, unknown>;
-      const alternatives = JSON.parse(row.alternatives as string) as string[];
-      expect(alternatives).toContain('Redis');
-      expect(alternatives).toContain('Memcached');
-    });
-
-    it('handles unknown tool name', () => {
-      const result = handleAdrToolCall('massu_adr_unknown', {}, db);
-      const text = result.content[0].text;
-      expect(text).toContain('Unknown ADR tool');
-    });
-  });
-});

package/src/__tests__/analytics.test.ts

@@ -1,282 +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 {
-  getAnalyticsToolDefinitions,
-  isAnalyticsTool,
-  calculateQualityScore,
-  storeQualityScore,
-  backfillQualityScores,
-  handleAnalyticsToolCall,
-  type QualityBreakdown,
-} from '../analytics.ts';
-
-function createTestDb(): Database.Database {
-  const db = new Database(':memory:');
-  db.pragma('journal_mode = WAL');
-
-  // Create minimal required schema for analytics
-  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 observations (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      type TEXT NOT NULL,
-      detail TEXT,
-      created_at TEXT NOT NULL
-    );
-
-    CREATE TABLE session_quality_scores (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL UNIQUE,
-      score INTEGER NOT NULL,
-      security_score INTEGER NOT NULL DEFAULT 0,
-      architecture_score INTEGER NOT NULL DEFAULT 0,
-      coupling_score INTEGER NOT NULL DEFAULT 0,
-      test_score INTEGER NOT NULL DEFAULT 0,
-      rule_compliance_score INTEGER NOT NULL DEFAULT 0,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-  `);
-
-  return db;
-}
-
-describe('analytics', () => {
-  let db: Database.Database;
-
-  beforeEach(() => {
-    db = createTestDb();
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  describe('getAnalyticsToolDefinitions', () => {
-    it('should return tool definitions for analytics tools', () => {
-      const defs = getAnalyticsToolDefinitions();
-      expect(defs.length).toBe(3);
-
-      const names = defs.map(d => d.name);
-      expect(names.some(n => n.includes('quality_score'))).toBe(true);
-      expect(names.some(n => n.includes('quality_trend'))).toBe(true);
-      expect(names.some(n => n.includes('quality_report'))).toBe(true);
-
-      // Check structure
-      for (const def of defs) {
-        expect(def.name).toBeTruthy();
-        expect(def.description).toBeTruthy();
-        expect(def.inputSchema).toBeTruthy();
-        expect(def.inputSchema.type).toBe('object');
-      }
-    });
-  });
-
-  describe('isAnalyticsTool', () => {
-    it('should return true for analytics tools', () => {
-      expect(isAnalyticsTool('massu_quality_score')).toBe(true);
-      expect(isAnalyticsTool('massu_quality_trend')).toBe(true);
-      expect(isAnalyticsTool('massu_quality_report')).toBe(true);
-    });
-
-    it('should return false for non-analytics tools', () => {
-      expect(isAnalyticsTool('massu_cost_session')).toBe(false);
-      expect(isAnalyticsTool('massu_audit_log')).toBe(false);
-      expect(isAnalyticsTool('random_tool')).toBe(false);
-    });
-
-    it('should handle base names without prefix', () => {
-      expect(isAnalyticsTool('quality_score')).toBe(true);
-      expect(isAnalyticsTool('quality_trend')).toBe(true);
-    });
-  });
-
-  describe('calculateQualityScore', () => {
-    it('should calculate quality score from observations', () => {
-      const sessionId = 'test-session-1';
-
-      // Insert session
-      db.prepare('INSERT INTO sessions (session_id, started_at, started_at_epoch) VALUES (?, ?, ?)').run(
-        sessionId,
-        new Date().toISOString(),
-        Math.floor(Date.now() / 1000)
-      );
-
-      // Insert observations
-      db.prepare('INSERT INTO observations (session_id, type, detail, created_at) VALUES (?, ?, ?, ?)').run(
-        sessionId, 'vr_pass', 'Security check passed', new Date().toISOString()
-      );
-      db.prepare('INSERT INTO observations (session_id, type, detail, created_at) VALUES (?, ?, ?, ?)').run(
-        sessionId, 'clean_commit', 'Clean commit with security improvements', new Date().toISOString()
-      );
-      db.prepare('INSERT INTO observations (session_id, type, detail, created_at) VALUES (?, ?, ?, ?)').run(
-        sessionId, 'bug_found', 'Bug found in architecture', new Date().toISOString()
-      );
-
-      const result = calculateQualityScore(db, sessionId);
-
-      expect(result.score).toBeGreaterThan(0);
-      expect(result.score).toBeLessThanOrEqual(100);
-      expect(result.breakdown).toBeDefined();
-      expect(result.breakdown.security).toBeDefined();
-      expect(result.breakdown.architecture).toBeDefined();
-    });
-
-    it('should start with base score of 50', () => {
-      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 result = calculateQualityScore(db, sessionId);
-      expect(result.score).toBe(50); // No observations = base score
-    });
-
-    it('should clamp score between 0 and 100', () => {
-      const sessionId = 'test-session-3';
-      db.prepare('INSERT INTO sessions (session_id, started_at, started_at_epoch) VALUES (?, ?, ?)').run(
-        sessionId,
-        new Date().toISOString(),
-        Math.floor(Date.now() / 1000)
-      );
-
-      // Add many negative observations
-      for (let i = 0; i < 10; i++) {
-        db.prepare('INSERT INTO observations (session_id, type, detail, created_at) VALUES (?, ?, ?, ?)').run(
-          sessionId, 'incident', 'Critical incident', new Date().toISOString()
-        );
-      }
-
-      const result = calculateQualityScore(db, sessionId);
-      expect(result.score).toBeGreaterThanOrEqual(0);
-      expect(result.score).toBeLessThanOrEqual(100);
-    });
-  });
-
-  describe('storeQualityScore', () => {
-    it('should store quality score in database', () => {
-      const sessionId = 'test-session-4';
-      db.prepare('INSERT INTO sessions (session_id, started_at, started_at_epoch) VALUES (?, ?, ?)').run(
-        sessionId,
-        new Date().toISOString(),
-        Math.floor(Date.now() / 1000)
-      );
-
-      const breakdown: QualityBreakdown = {
-        security: 5,
-        architecture: -3,
-        coupling: 0,
-        tests: 2,
-        rule_compliance: 1,
-      };
-
-      storeQualityScore(db, sessionId, 75, breakdown);
-
-      const stored = db.prepare('SELECT * FROM session_quality_scores WHERE session_id = ?').get(sessionId) as Record<string, unknown>;
-      expect(stored).toBeDefined();
-      expect(stored.session_id).toBe(sessionId);
-      expect(stored.score).toBe(75);
-      expect(stored.security_score).toBe(5);
-      expect(stored.architecture_score).toBe(-3);
-      expect(stored.coupling_score).toBe(0);
-      expect(stored.test_score).toBe(2);
-      expect(stored.rule_compliance_score).toBe(1);
-    });
-  });
-
-  describe('backfillQualityScores', () => {
-    it('should backfill scores for sessions without them', () => {
-      // Create sessions
-      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)
-        );
-        db.prepare('INSERT INTO observations (session_id, type, detail, created_at) VALUES (?, ?, ?, ?)').run(
-          sid, 'vr_pass', 'Test passed', new Date().toISOString()
-        );
-      }
-
-      const backfilled = backfillQualityScores(db);
-      expect(backfilled).toBe(3);
-
-      // Verify all sessions now have scores
-      const scores = db.prepare('SELECT COUNT(*) as count FROM session_quality_scores').get() as { count: number };
-      expect(scores.count).toBe(3);
-    });
-
-    it('should not backfill sessions that already have scores', () => {
-      const sessionId = 'session-with-score';
-      db.prepare('INSERT INTO sessions (session_id, started_at, started_at_epoch) VALUES (?, ?, ?)').run(
-        sessionId,
-        new Date().toISOString(),
-        Math.floor(Date.now() / 1000)
-      );
-
-      // Already has a score
-      const breakdown: QualityBreakdown = {
-        security: 0,
-        architecture: 0,
-        coupling: 0,
-        tests: 0,
-        rule_compliance: 0,
-      };
-      storeQualityScore(db, sessionId, 50, breakdown);
-
-      const backfilled = backfillQualityScores(db);
-      expect(backfilled).toBe(0);
-    });
-  });
-
-  describe('handleAnalyticsToolCall', () => {
-    it('should handle quality_score tool call', () => {
-      const sessionId = 'test-session-5';
-      db.prepare('INSERT INTO sessions (session_id, started_at, started_at_epoch) VALUES (?, ?, ?)').run(
-        sessionId,
-        new Date().toISOString(),
-        Math.floor(Date.now() / 1000)
-      );
-      db.prepare('INSERT INTO observations (session_id, type, detail, created_at) VALUES (?, ?, ?, ?)').run(
-        sessionId, 'vr_pass', 'Security tests passed', new Date().toISOString()
-      );
-
-      const result = handleAnalyticsToolCall('massu_quality_score', { 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('Quality Score');
-      expect(text).toContain('Breakdown');
-    });
-
-    it('should return error for missing session_id', () => {
-      const result = handleAnalyticsToolCall('massu_quality_score', {}, 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 = handleAnalyticsToolCall('massu_unknown_analytics_tool', {}, db);
-
-      expect(result.content).toBeDefined();
-      expect(result.content[0].type).toBe('text');
-      expect(result.content[0].text).toContain('Unknown analytics tool');
-    });
-  });
-});