@massu/core 0.1.1 → 0.1.2

package/src/__tests__/team-knowledge.test.ts

@@ -1,327 +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 {
-  getTeamToolDefinitions,
-  isTeamTool,
-  calculateExpertise,
-  updateExpertise,
-  detectConflicts,
-  shareObservation,
-  handleTeamToolCall,
-} from '../team-knowledge.ts';
-
-function createTestDb(): Database.Database {
-  const db = new Database(':memory:');
-  db.exec(`
-    CREATE TABLE developer_expertise (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      developer_id TEXT NOT NULL,
-      module TEXT NOT NULL,
-      session_count INTEGER NOT NULL DEFAULT 0,
-      observation_count INTEGER NOT NULL DEFAULT 0,
-      expertise_score INTEGER NOT NULL DEFAULT 0,
-      last_active TEXT DEFAULT (datetime('now')),
-      UNIQUE(developer_id, module)
-    );
-
-    CREATE TABLE shared_observations (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      original_id INTEGER,
-      developer_id TEXT NOT NULL,
-      project TEXT NOT NULL,
-      observation_type TEXT NOT NULL,
-      summary TEXT NOT NULL,
-      file_path TEXT,
-      module TEXT,
-      severity INTEGER NOT NULL DEFAULT 3,
-      is_shared INTEGER NOT NULL DEFAULT 0,
-      shared_at TEXT,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-
-    CREATE TABLE knowledge_conflicts (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      file_path TEXT NOT NULL,
-      developer_a TEXT NOT NULL,
-      developer_b TEXT NOT NULL,
-      conflict_type TEXT NOT NULL DEFAULT 'concurrent_edit',
-      resolved INTEGER NOT NULL DEFAULT 0,
-      detected_at TEXT DEFAULT (datetime('now'))
-    );
-
-    CREATE TABLE observations (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      type TEXT NOT NULL,
-      title TEXT NOT NULL,
-      detail TEXT,
-      files_involved TEXT DEFAULT '[]',
-      created_at_epoch INTEGER NOT NULL
-    );
-  `);
-  return db;
-}
-
-describe('team-knowledge', () => {
-  let db: Database.Database;
-
-  beforeEach(() => {
-    db = createTestDb();
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  describe('getTeamToolDefinitions', () => {
-    it('returns 3 tool definitions', () => {
-      const tools = getTeamToolDefinitions();
-      expect(tools).toHaveLength(3);
-      expect(tools.map(t => t.name.split('_').slice(-2).join('_'))).toEqual([
-        'team_search',
-        'team_expertise',
-        'team_conflicts',
-      ]);
-    });
-
-    it('team_search requires query', () => {
-      const tools = getTeamToolDefinitions();
-      const searchTool = tools.find(t => t.name.endsWith('_team_search'));
-      expect(searchTool?.inputSchema.required).toEqual(['query']);
-    });
-  });
-
-  describe('isTeamTool', () => {
-    it('returns true for team tool names', () => {
-      expect(isTeamTool('massu_team_search')).toBe(true);
-      expect(isTeamTool('massu_team_expertise')).toBe(true);
-      expect(isTeamTool('massu_team_conflicts')).toBe(true);
-    });
-
-    it('returns false for non-team tool names', () => {
-      expect(isTeamTool('massu_security_score')).toBe(false);
-      expect(isTeamTool('massu_unknown')).toBe(false);
-    });
-  });
-
-  describe('calculateExpertise', () => {
-    it('calculates expertise from session and observation counts', () => {
-      const score = calculateExpertise(10, 50);
-      expect(score).toBeGreaterThan(0);
-      expect(score).toBeLessThanOrEqual(100);
-    });
-
-    it('returns higher score for more sessions', () => {
-      const score1 = calculateExpertise(5, 10);
-      const score2 = calculateExpertise(20, 10);
-      expect(score2).toBeGreaterThan(score1);
-    });
-
-    it('returns higher score for more observations', () => {
-      const score1 = calculateExpertise(5, 10);
-      const score2 = calculateExpertise(5, 50);
-      expect(score2).toBeGreaterThan(score1);
-    });
-
-    it('caps score at 100', () => {
-      const score = calculateExpertise(1000, 1000);
-      expect(score).toBeLessThanOrEqual(100);
-    });
-
-    it('handles zero counts', () => {
-      const score = calculateExpertise(0, 0);
-      expect(score).toBe(0);
-    });
-  });
-
-  describe('updateExpertise', () => {
-    it('creates expertise record for new developer-module pair', () => {
-      // Insert observation with file changes
-      db.prepare(`
-        INSERT INTO observations (session_id, type, title, detail, files_involved, created_at_epoch)
-        VALUES (?, ?, ?, ?, ?, ?)
-      `).run('session-1', 'feature', 'Added feature', 'Details', JSON.stringify(['src/routers/orders.ts']), Date.now());
-
-      updateExpertise(db, 'dev-alice', 'session-1');
-
-      const expertise = db.prepare(
-        'SELECT * FROM developer_expertise WHERE developer_id = ? AND module = ?'
-      ).get('dev-alice', 'orders') as Record<string, unknown> | undefined;
-
-      expect(expertise).toBeDefined();
-      expect(expertise!.session_count).toBe(1);
-      expect(expertise!.expertise_score).toBeGreaterThan(0);
-    });
-
-    it('updates existing expertise record', () => {
-      // Create initial expertise
-      db.prepare(`
-        INSERT INTO developer_expertise (developer_id, module, session_count, observation_count, expertise_score)
-        VALUES (?, ?, ?, ?, ?)
-      `).run('dev-bob', 'products', 5, 20, 50);
-
-      // Add new observation
-      db.prepare(`
-        INSERT INTO observations (session_id, type, title, detail, files_involved, created_at_epoch)
-        VALUES (?, ?, ?, ?, ?, ?)
-      `).run('session-2', 'bugfix', 'Fixed bug', 'Details', JSON.stringify(['src/routers/products.ts']), Date.now());
-
-      updateExpertise(db, 'dev-bob', 'session-2');
-
-      const expertise = db.prepare(
-        'SELECT * FROM developer_expertise WHERE developer_id = ? AND module = ?'
-      ).get('dev-bob', 'products') as Record<string, unknown>;
-
-      expect(expertise.session_count).toBe(6);
-      expect(expertise.observation_count).toBeGreaterThan(20);
-    });
-  });
-
-  describe('detectConflicts', () => {
-    it('returns empty array when no conflicts', () => {
-      const conflicts = detectConflicts(db, 7);
-      expect(conflicts).toEqual([]);
-    });
-
-    it('detects concurrent edits by different developers', () => {
-      // Add observations for two developers on same file
-      db.prepare(`
-        INSERT INTO shared_observations (developer_id, project, observation_type, summary, file_path, is_shared, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
-      `).run('dev-alice', 'myproject', 'edit', 'Alice edited file', 'src/app.ts', 1);
-
-      db.prepare(`
-        INSERT INTO shared_observations (developer_id, project, observation_type, summary, file_path, is_shared, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
-      `).run('dev-bob', 'myproject', 'edit', 'Bob edited file', 'src/app.ts', 1);
-
-      const conflicts = detectConflicts(db, 7);
-      expect(conflicts.length).toBeGreaterThan(0);
-      expect(conflicts[0].filePath).toBe('src/app.ts');
-      expect(conflicts[0].conflictType).toBe('concurrent_edit');
-    });
-
-    it('respects days back parameter', () => {
-      // Add old observation
-      db.prepare(`
-        INSERT INTO shared_observations (developer_id, project, observation_type, summary, file_path, is_shared, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, datetime('now', '-10 days'))
-      `).run('dev-alice', 'myproject', 'edit', 'Old edit', 'src/old.ts', 1);
-
-      db.prepare(`
-        INSERT INTO shared_observations (developer_id, project, observation_type, summary, file_path, is_shared, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, datetime('now', '-10 days'))
-      `).run('dev-bob', 'myproject', 'edit', 'Old edit', 'src/old.ts', 1);
-
-      const conflicts = detectConflicts(db, 5); // Only look back 5 days
-      expect(conflicts).toEqual([]);
-    });
-  });
-
-  describe('shareObservation', () => {
-    it('creates shared observation record', () => {
-      const id = shareObservation(
-        db,
-        'dev-alice',
-        'myproject',
-        'discovery',
-        'Found interesting pattern',
-        {
-          filePath: 'src/utils.ts',
-          module: 'utils',
-          severity: 4,
-        }
-      );
-
-      expect(id).toBeGreaterThan(0);
-
-      const obs = db.prepare('SELECT * FROM shared_observations WHERE id = ?').get(id) as Record<string, unknown>;
-      expect(obs.developer_id).toBe('dev-alice');
-      expect(obs.observation_type).toBe('discovery');
-      expect(obs.summary).toBe('Found interesting pattern');
-      expect(obs.file_path).toBe('src/utils.ts');
-      expect(obs.module).toBe('utils');
-      expect(obs.severity).toBe(4);
-      expect(obs.is_shared).toBe(1);
-    });
-
-    it('uses default severity when not provided', () => {
-      const id = shareObservation(
-        db,
-        'dev-bob',
-        'myproject',
-        'bugfix',
-        'Fixed critical bug'
-      );
-
-      const obs = db.prepare('SELECT severity FROM shared_observations WHERE id = ?').get(id) as { severity: number };
-      expect(obs.severity).toBe(3);
-    });
-  });
-
-  describe('handleTeamToolCall', () => {
-    it('handles team_search with no results', () => {
-      const result = handleTeamToolCall('massu_team_search', { query: 'nonexistent' }, db);
-      const text = result.content[0].text;
-      expect(text).toContain('No shared observations found');
-    });
-
-    it('handles team_search with results', () => {
-      shareObservation(db, 'dev-alice', 'myproject', 'discovery', 'Found authentication bug', {
-        module: 'auth',
-      });
-
-      const result = handleTeamToolCall('massu_team_search', { query: 'authentication' }, db);
-      const text = result.content[0].text;
-      expect(text).toContain('Team Knowledge');
-      expect(text).toContain('dev-alice');
-      expect(text).toContain('discovery');
-    });
-
-    it('handles team_expertise overview when no module specified', () => {
-      db.prepare(`
-        INSERT INTO developer_expertise (developer_id, module, session_count, observation_count, expertise_score)
-        VALUES (?, ?, ?, ?, ?)
-      `).run('dev-alice', 'orders', 10, 50, 75);
-
-      const result = handleTeamToolCall('massu_team_expertise', {}, db);
-      const text = result.content[0].text;
-      expect(text).toContain('Team Expertise Overview');
-      expect(text).toContain('orders');
-    });
-
-    it('handles team_expertise for specific module', () => {
-      db.prepare(`
-        INSERT INTO developer_expertise (developer_id, module, session_count, observation_count, expertise_score)
-        VALUES (?, ?, ?, ?, ?)
-      `).run('dev-alice', 'products', 15, 60, 85);
-
-      db.prepare(`
-        INSERT INTO developer_expertise (developer_id, module, session_count, observation_count, expertise_score)
-        VALUES (?, ?, ?, ?, ?)
-      `).run('dev-bob', 'products', 8, 30, 55);
-
-      const result = handleTeamToolCall('massu_team_expertise', { module: 'products' }, db);
-      const text = result.content[0].text;
-      expect(text).toContain('Expertise: products');
-      expect(text).toContain('dev-alice');
-      expect(text).toContain('dev-bob');
-      expect(text).toContain('85'); // Alice's score should appear first (higher)
-    });
-
-    it('handles team_conflicts with no conflicts', () => {
-      const result = handleTeamToolCall('massu_team_conflicts', {}, db);
-      const text = result.content[0].text;
-      expect(text).toContain('No concurrent work conflicts');
-    });
-
-    it('handles unknown tool name', () => {
-      const result = handleTeamToolCall('massu_team_unknown', {}, db);
-      const text = result.content[0].text;
-      expect(text).toContain('Unknown team tool');
-    });
-  });
-});

package/src/__tests__/tools.test.ts

@@ -1,340 +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 { getToolDefinitions, handleToolCall } from '../tools.ts';
-
-// Mock all dependencies
-vi.mock('../config.ts', () => ({
-  getConfig: () => ({
-    toolPrefix: 'massu',
-    framework: { type: 'typescript', router: 'trpc', orm: 'prisma' },
-    paths: {
-      source: 'src',
-      routers: 'src/server/api/routers',
-      middleware: 'src/middleware.ts',
-    },
-    domains: [
-      {
-        name: 'test',
-        routers: ['test'],
-        pages: ['src/app/test/**'],
-        tables: ['test_table'],
-        allowedImportsFrom: ['*'],
-      },
-    ],
-  }),
-  getProjectRoot: () => '/test/project',
-  getResolvedPaths: () => ({
-    codegraphDbPath: '/test/codegraph.db',
-    dataDbPath: '/test/data.db',
-  }),
-}));
-
-vi.mock('../memory-db.ts', () => ({
-  getMemoryDb: () => createMockDb(),
-}));
-
-vi.mock('../db.ts', async (importOriginal) => {
-  const actual = await importOriginal() as Record<string, unknown>;
-  return {
-    ...actual,
-    isDataStale: () => false,
-    updateBuildTimestamp: vi.fn(),
-  };
-});
-
-vi.mock('../import-resolver.ts', () => ({
-  buildImportIndex: () => 0,
-}));
-
-vi.mock('../trpc-index.ts', () => ({
-  buildTrpcIndex: () => ({ totalProcedures: 0, withCallers: 0, withoutCallers: 0 }),
-}));
-
-vi.mock('../page-deps.ts', () => ({
-  buildPageDeps: () => 0,
-  findAffectedPages: () => [],
-}));
-
-vi.mock('../middleware-tree.ts', () => ({
-  buildMiddlewareTree: () => 0,
-  isInMiddlewareTree: () => false,
-  getMiddlewareTree: () => [],
-}));
-
-vi.mock('../rules.ts', () => ({
-  matchRules: () => [],
-  globMatch: () => false,
-}));
-
-vi.mock('../sentinel-scanner.ts', () => ({
-  runFeatureScan: () => ({ registered: 0, fromProcedures: 0, fromPages: 0, fromComponents: 0 }),
-}));
-
-function createMockDb(): Database.Database {
-  const db = new Database(':memory:');
-  db.pragma('journal_mode = WAL');
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS massu_imports (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      source_file TEXT NOT NULL,
-      target_file TEXT NOT NULL,
-      import_type TEXT NOT NULL,
-      imported_names TEXT NOT NULL DEFAULT '[]',
-      line INTEGER NOT NULL DEFAULT 0
-    );
-
-    CREATE TABLE IF NOT EXISTS massu_trpc_procedures (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      router_file TEXT NOT NULL,
-      router_name TEXT NOT NULL,
-      procedure_name TEXT NOT NULL,
-      procedure_type TEXT NOT NULL,
-      has_ui_caller INTEGER NOT NULL DEFAULT 0
-    );
-
-    CREATE TABLE IF NOT EXISTS massu_trpc_call_sites (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      procedure_id INTEGER NOT NULL,
-      file TEXT NOT NULL,
-      line INTEGER NOT NULL DEFAULT 0,
-      call_pattern TEXT NOT NULL,
-      FOREIGN KEY (procedure_id) REFERENCES massu_trpc_procedures(id)
-    );
-
-    CREATE TABLE IF NOT EXISTS massu_middleware_tree (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      file TEXT NOT NULL UNIQUE
-    );
-
-    CREATE TABLE IF NOT EXISTS massu_meta (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-  `);
-
-  return db;
-}
-
-function createMockCodeGraphDb(): Database.Database {
-  const db = new Database(':memory:');
-  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 DEFAULT 0
-    );
-
-    CREATE TABLE IF NOT EXISTS nodes (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      file_path TEXT NOT NULL,
-      name TEXT NOT NULL,
-      kind TEXT NOT NULL,
-      start_line INTEGER,
-      end_line INTEGER
-    );
-  `);
-
-  // Seed with at least one file to pass staleness check
-  db.prepare('INSERT INTO files (path, indexed_at) VALUES (?, ?)').run('test.ts', Math.floor(Date.now() / 1000));
-
-  return db;
-}
-
-describe('Tools Module', () => {
-  let dataDb: Database.Database;
-  let codegraphDb: Database.Database;
-
-  beforeEach(() => {
-    dataDb = createMockDb();
-    codegraphDb = createMockCodeGraphDb();
-  });
-
-  afterEach(() => {
-    dataDb.close();
-    codegraphDb.close();
-  });
-
-  describe('getToolDefinitions', () => {
-    it('returns an array of tool definitions', () => {
-      const tools = getToolDefinitions();
-      expect(Array.isArray(tools)).toBe(true);
-      expect(tools.length).toBeGreaterThan(0);
-    });
-
-    it('includes core tools', () => {
-      const tools = getToolDefinitions();
-      const toolNames = tools.map(t => t.name);
-      expect(toolNames).toContain('massu_sync');
-      expect(toolNames).toContain('massu_context');
-      expect(toolNames).toContain('massu_impact');
-    });
-
-    it('includes trpc tools when framework.router is trpc', () => {
-      const tools = getToolDefinitions();
-      const toolNames = tools.map(t => t.name);
-      expect(toolNames).toContain('massu_trpc_map');
-      expect(toolNames).toContain('massu_coupling_check');
-    });
-
-    it('includes domain tools when domains are configured', () => {
-      const tools = getToolDefinitions();
-      const toolNames = tools.map(t => t.name);
-      expect(toolNames).toContain('massu_domains');
-    });
-
-    it('includes schema tools when framework.orm is prisma', () => {
-      const tools = getToolDefinitions();
-      const toolNames = tools.map(t => t.name);
-      expect(toolNames).toContain('massu_schema');
-    });
-
-    it('each tool has required properties', () => {
-      const tools = getToolDefinitions();
-      for (const tool of tools) {
-        expect(tool.name).toBeTruthy();
-        expect(tool.description).toBeTruthy();
-        expect(tool.inputSchema).toBeTruthy();
-        expect(typeof tool.inputSchema).toBe('object');
-      }
-    });
-  });
-
-  describe('handleToolCall - massu_sync', () => {
-    it('rebuilds indexes and returns summary', () => {
-      const result = handleToolCall('massu_sync', {}, dataDb, codegraphDb);
-      expect(result.content[0].type).toBe('text');
-      expect(result.content[0].text).toContain('Indexes rebuilt');
-    });
-  });
-
-  describe('handleToolCall - massu_context', () => {
-    beforeEach(() => {
-      codegraphDb.prepare(`
-        INSERT INTO nodes (file_path, name, kind, start_line, end_line)
-        VALUES ('src/test.ts', 'testFunction', 'function', 1, 10)
-      `).run();
-
-      dataDb.prepare(`
-        INSERT INTO massu_imports (source_file, target_file, import_type)
-        VALUES ('src/test.ts', 'src/utils.ts', 'named')
-      `).run();
-    });
-
-    it('returns context for a file', () => {
-      const result = handleToolCall('massu_context', { file: 'src/test.ts' }, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('CodeGraph Nodes');
-      expect(result.content[0].text).toContain('testFunction');
-    });
-
-    it('includes domain classification', () => {
-      const result = handleToolCall('massu_context', { file: 'src/test.ts' }, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('Domain:');
-    });
-
-    it('includes import information', () => {
-      const result = handleToolCall('massu_context', { file: 'src/test.ts' }, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('Imports');
-    });
-  });
-
-  describe('handleToolCall - massu_impact', () => {
-    it('returns impact analysis for a file', () => {
-      const result = handleToolCall('massu_impact', { file: 'src/test.ts' }, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('Impact Analysis');
-      expect(result.content[0].text).toContain('src/test.ts');
-    });
-
-    it('includes middleware tree check', () => {
-      const result = handleToolCall('massu_impact', { file: 'src/test.ts' }, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('Middleware');
-    });
-
-    it('includes domain information', () => {
-      const result = handleToolCall('massu_impact', { file: 'src/test.ts' }, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('Domain:');
-    });
-  });
-
-  describe('handleToolCall - massu_trpc_map', () => {
-    beforeEach(() => {
-      dataDb.prepare(`
-        INSERT INTO massu_trpc_procedures (router_file, router_name, procedure_name, procedure_type, has_ui_caller)
-        VALUES
-          ('src/server/api/routers/test.ts', 'test', 'getTest', 'query', 1),
-          ('src/server/api/routers/test.ts', 'test', 'updateTest', 'mutation', 0)
-      `).run();
-    });
-
-    it('returns summary without arguments', () => {
-      const result = handleToolCall('massu_trpc_map', {}, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('tRPC Procedure Summary');
-      expect(result.content[0].text).toContain('Total procedures');
-    });
-
-    it('filters by router', () => {
-      const result = handleToolCall('massu_trpc_map', { router: 'test' }, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('Router: test');
-      expect(result.content[0].text).toContain('getTest');
-      expect(result.content[0].text).toContain('updateTest');
-    });
-
-    it('shows uncoupled procedures', () => {
-      const result = handleToolCall('massu_trpc_map', { uncoupled: true }, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('Uncoupled Procedures');
-      expect(result.content[0].text).toContain('updateTest');
-    });
-  });
-
-  describe('handleToolCall - massu_domains', () => {
-    beforeEach(() => {
-      dataDb.prepare(`
-        INSERT INTO massu_imports (source_file, target_file, import_type)
-        VALUES ('src/app/test/page.tsx', 'src/utils/helper.ts', 'named')
-      `).run();
-
-      codegraphDb.prepare(`
-        INSERT INTO files (path, indexed_at)
-        VALUES ('src/app/test/page.tsx', ?)
-      `).run(Math.floor(Date.now() / 1000));
-    });
-
-    it('classifies a file', () => {
-      const result = handleToolCall('massu_domains', { file: 'src/app/test/page.tsx' }, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('Domain:');
-    });
-
-    it('shows domain summary without arguments', () => {
-      const result = handleToolCall('massu_domains', {}, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('Domain Summary');
-    });
-
-    it('lists files in domain', () => {
-      const result = handleToolCall('massu_domains', { domain: 'test' }, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('Domain: test');
-    });
-  });
-
-  describe('handleToolCall - unknown tool', () => {
-    it('returns error for unknown tool', () => {
-      const result = handleToolCall('massu_unknown_tool', {}, dataDb, codegraphDb);
-      expect(result.content[0].text).toContain('Unknown tool');
-    });
-  });
-
-  describe('handleToolCall - error handling', () => {
-    it('catches and returns errors', () => {
-      // Force an error by passing invalid database
-      const badDb = new Database(':memory:');
-      badDb.close(); // Closed DB will cause errors
-
-      const result = handleToolCall('massu_context', { file: 'test.ts' }, badDb, codegraphDb);
-      expect(result.content[0].text).toContain('Error');
-    });
-  });
-});