@massu/core 0.1.1 → 0.1.2

package/src/__tests__/prompt-analyzer.test.ts

@@ -1,298 +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 {
-  getPromptToolDefinitions,
-  isPromptTool,
-  categorizePrompt,
-  hashPrompt,
-  detectOutcome,
-  analyzeSessionPrompts,
-  handlePromptToolCall,
-} from '../prompt-analyzer.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 user_prompts (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      prompt_text TEXT NOT NULL,
-      prompt_number INTEGER NOT NULL DEFAULT 1,
-      created_at TEXT NOT NULL,
-      created_at_epoch INTEGER NOT NULL
-    );
-
-    CREATE TABLE prompt_outcomes (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      prompt_hash TEXT NOT NULL,
-      prompt_text TEXT NOT NULL,
-      prompt_category TEXT NOT NULL DEFAULT 'feature',
-      word_count INTEGER NOT NULL DEFAULT 0,
-      outcome TEXT NOT NULL DEFAULT 'success' CHECK(outcome IN ('success', 'partial', 'failure', 'abandoned')),
-      corrections_needed INTEGER NOT NULL DEFAULT 0,
-      follow_up_prompts INTEGER NOT NULL DEFAULT 0,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-  `);
-
-  return db;
-}
-
-describe('prompt-analyzer', () => {
-  let db: Database.Database;
-
-  beforeEach(() => {
-    db = createTestDb();
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  describe('getPromptToolDefinitions', () => {
-    it('should return tool definitions for prompt tools', () => {
-      const defs = getPromptToolDefinitions();
-      expect(defs.length).toBe(2);
-
-      const names = defs.map(d => d.name);
-      expect(names.some(n => n.includes('prompt_effectiveness'))).toBe(true);
-      expect(names.some(n => n.includes('prompt_suggestions'))).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('isPromptTool', () => {
-    it('should return true for prompt tools', () => {
-      expect(isPromptTool('massu_prompt_effectiveness')).toBe(true);
-      expect(isPromptTool('massu_prompt_suggestions')).toBe(true);
-    });
-
-    it('should return false for non-prompt tools', () => {
-      expect(isPromptTool('massu_cost_session')).toBe(false);
-      expect(isPromptTool('massu_quality_score')).toBe(false);
-      expect(isPromptTool('random_tool')).toBe(false);
-    });
-
-    it('should handle base names without prefix', () => {
-      expect(isPromptTool('prompt_effectiveness')).toBe(true);
-      expect(isPromptTool('prompt_suggestions')).toBe(true);
-    });
-  });
-
-  describe('categorizePrompt', () => {
-    it('should categorize bugfix prompts', () => {
-      expect(categorizePrompt('Fix the bug in auth.ts')).toBe('bugfix');
-      expect(categorizePrompt('There is an error in the validation')).toBe('bugfix');
-      expect(categorizePrompt('The app crash on submit')).toBe('bugfix');
-    });
-
-    it('should categorize refactor prompts', () => {
-      expect(categorizePrompt('Refactor the user module')).toBe('refactor');
-      expect(categorizePrompt('Rename the function to be more clear')).toBe('refactor');
-      expect(categorizePrompt('Extract this into a separate component')).toBe('refactor');
-    });
-
-    it('should categorize question prompts', () => {
-      expect(categorizePrompt('What does this function do?')).toBe('question');
-      expect(categorizePrompt('How do I implement authentication?')).toBe('question');
-      expect(categorizePrompt('Explain the database schema')).toBe('question');
-    });
-
-    it('should categorize command prompts', () => {
-      expect(categorizePrompt('/commit')).toBe('command');
-      expect(categorizePrompt('/massu-loop')).toBe('command');
-    });
-
-    it('should categorize feature prompts', () => {
-      expect(categorizePrompt('Add a new user registration form')).toBe('feature');
-      expect(categorizePrompt('Create a dashboard component')).toBe('feature');
-      expect(categorizePrompt('Implement password reset')).toBe('feature');
-    });
-
-    it('should default to feature for ambiguous prompts', () => {
-      expect(categorizePrompt('Update the styles')).toBe('feature');
-      expect(categorizePrompt('Make it better')).toBe('feature');
-    });
-  });
-
-  describe('hashPrompt', () => {
-    it('should generate consistent hashes for same prompt', () => {
-      const hash1 = hashPrompt('Fix the bug in auth.ts');
-      const hash2 = hashPrompt('Fix the bug in auth.ts');
-      expect(hash1).toBe(hash2);
-    });
-
-    it('should normalize whitespace', () => {
-      const hash1 = hashPrompt('Fix   the    bug');
-      const hash2 = hashPrompt('Fix the bug');
-      expect(hash1).toBe(hash2);
-    });
-
-    it('should be case-insensitive', () => {
-      const hash1 = hashPrompt('Fix The Bug');
-      const hash2 = hashPrompt('fix the bug');
-      expect(hash1).toBe(hash2);
-    });
-
-    it('should return different hashes for different prompts', () => {
-      const hash1 = hashPrompt('Fix the bug');
-      const hash2 = hashPrompt('Add a feature');
-      expect(hash1).not.toBe(hash2);
-    });
-
-    it('should return 16-character hash', () => {
-      const hash = hashPrompt('Test prompt');
-      expect(hash.length).toBe(16);
-    });
-  });
-
-  describe('detectOutcome', () => {
-    it('should detect success outcome', () => {
-      const followUps = ['Great, that works!', 'Perfect, thanks'];
-      const responses = ['Done.'];
-      const result = detectOutcome(followUps, responses);
-      expect(result.outcome).toBe('success');
-      expect(result.correctionsNeeded).toBe(0);
-    });
-
-    it('should detect partial outcome with corrections', () => {
-      const followUps = ['No, that\'s wrong', 'Fix this issue', 'Try again'];
-      const responses = ['Updated.'];
-      const result = detectOutcome(followUps, responses);
-      expect(result.outcome).toBe('partial');
-      expect(result.correctionsNeeded).toBeGreaterThan(0);
-    });
-
-    it('should detect abandoned outcome', () => {
-      const followUps = ['Nevermind, skip this', 'Let\'s move on'];
-      const responses = ['OK.'];
-      const result = detectOutcome(followUps, responses);
-      expect(result.outcome).toBe('abandoned');
-    });
-
-    it('should detect failure from assistant responses', () => {
-      const followUps: string[] = [];
-      const responses = ['Error: cannot complete', 'Failed to process'];
-      const result = detectOutcome(followUps, responses);
-      expect(result.outcome).toBe('failure');
-    });
-
-    it('should count follow-up prompts', () => {
-      const followUps = ['One', 'Two', 'Three'];
-      const responses: string[] = [];
-      const result = detectOutcome(followUps, responses);
-      expect(result.followUpCount).toBe(3);
-    });
-  });
-
-  describe('analyzeSessionPrompts', () => {
-    it('should analyze prompts from a session', () => {
-      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 prompts = [
-        'Fix the bug in auth',
-        'Add validation',
-        'Refactor the code',
-      ];
-
-      for (let i = 0; i < prompts.length; i++) {
-        db.prepare('INSERT INTO user_prompts (session_id, prompt_text, prompt_number, created_at, created_at_epoch) VALUES (?, ?, ?, ?, ?)').run(
-          sessionId,
-          prompts[i],
-          i + 1,
-          new Date().toISOString(),
-          Math.floor(Date.now() / 1000)
-        );
-      }
-
-      const stored = analyzeSessionPrompts(db, sessionId);
-      expect(stored).toBe(3);
-
-      const outcomes = db.prepare('SELECT * FROM prompt_outcomes WHERE session_id = ?').all(sessionId) as Array<Record<string, unknown>>;
-      expect(outcomes.length).toBe(3);
-
-      for (const outcome of outcomes) {
-        expect(outcome.prompt_category).toBeTruthy();
-        expect(outcome.prompt_hash).toBeTruthy();
-        expect(outcome.word_count).toBeGreaterThan(0);
-      }
-    });
-
-    it('should skip duplicate prompts', () => {
-      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)
-      );
-
-      db.prepare('INSERT INTO user_prompts (session_id, prompt_text, prompt_number, created_at, created_at_epoch) VALUES (?, ?, ?, ?, ?)').run(
-        sessionId,
-        'Fix the bug',
-        1,
-        new Date().toISOString(),
-        Math.floor(Date.now() / 1000)
-      );
-
-      analyzeSessionPrompts(db, sessionId);
-      const first = analyzeSessionPrompts(db, sessionId);
-
-      expect(first).toBe(0); // No new prompts stored
-    });
-  });
-
-  describe('handlePromptToolCall', () => {
-    it('should handle prompt_suggestions tool call', () => {
-      const result = handlePromptToolCall('massu_prompt_suggestions', { prompt: 'Fix the bug' }, 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('Prompt Analysis');
-      expect(text).toContain('Category');
-    });
-
-    it('should return error for missing prompt', () => {
-      const result = handlePromptToolCall('massu_prompt_suggestions', {}, 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 = handlePromptToolCall('massu_unknown_prompt_tool', {}, db);
-
-      expect(result.content).toBeDefined();
-      expect(result.content[0].type).toBe('text');
-      expect(result.content[0].text).toContain('Unknown prompt tool');
-    });
-  });
-});

package/src/__tests__/regression-detector.test.ts

@@ -1,295 +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 {
-  getRegressionToolDefinitions,
-  isRegressionTool,
-  calculateHealthScore,
-  trackModification,
-  recordTestResult,
-  handleRegressionToolCall,
-} from '../regression-detector.ts';
-
-function createTestDb(): Database.Database {
-  const db = new Database(':memory:');
-  db.exec(`
-    CREATE TABLE feature_health (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      feature_key TEXT NOT NULL UNIQUE,
-      health_score INTEGER NOT NULL DEFAULT 100,
-      tests_passing INTEGER NOT NULL DEFAULT 0,
-      tests_failing INTEGER NOT NULL DEFAULT 0,
-      test_coverage_pct REAL,
-      modifications_since_test INTEGER NOT NULL DEFAULT 0,
-      last_modified TEXT,
-      last_tested TEXT,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-  `);
-  return db;
-}
-
-describe('regression-detector', () => {
-  let db: Database.Database;
-
-  beforeEach(() => {
-    db = createTestDb();
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  describe('getRegressionToolDefinitions', () => {
-    it('returns 2 tool definitions', () => {
-      const tools = getRegressionToolDefinitions();
-      expect(tools).toHaveLength(2);
-      expect(tools.map(t => t.name.split('_').slice(-2).join('_'))).toEqual([
-        'feature_health',
-        'regression_risk',
-      ]);
-    });
-
-    it('has required fields in tool definitions', () => {
-      const tools = getRegressionToolDefinitions();
-      tools.forEach(tool => {
-        expect(tool.name).toBeTruthy();
-        expect(tool.description).toBeTruthy();
-        expect(tool.inputSchema).toBeDefined();
-      });
-    });
-  });
-
-  describe('isRegressionTool', () => {
-    it('returns true for regression tool names', () => {
-      expect(isRegressionTool('massu_feature_health')).toBe(true);
-      expect(isRegressionTool('massu_regression_risk')).toBe(true);
-    });
-
-    it('returns false for non-regression tool names', () => {
-      expect(isRegressionTool('massu_security_score')).toBe(false);
-      expect(isRegressionTool('massu_unknown')).toBe(false);
-    });
-  });
-
-  describe('calculateHealthScore', () => {
-    it('returns 100 for healthy feature', () => {
-      const score = calculateHealthScore(
-        10, // tests passing
-        0,  // tests failing
-        0,  // modifications since test
-        new Date().toISOString(),
-        new Date().toISOString()
-      );
-      expect(score).toBe(100);
-    });
-
-    it('reduces score for failing tests', () => {
-      const score = calculateHealthScore(5, 2, 0, null, null);
-      expect(score).toBeLessThan(100);
-      expect(score).toBeLessThanOrEqual(80); // -20 for 2 failing tests
-    });
-
-    it('reduces score for untested modifications', () => {
-      const score = calculateHealthScore(10, 0, 3, null, null);
-      expect(score).toBeLessThan(100);
-      expect(score).toBeLessThanOrEqual(85); // -15 for 3 modifications
-    });
-
-    it('reduces score for modified but never tested', () => {
-      const score = calculateHealthScore(0, 0, 0, null, new Date().toISOString());
-      expect(score).toBeLessThan(100);
-      expect(score).toBe(70); // -30 for never tested
-    });
-
-    it('reduces score for time gap between modification and test', () => {
-      const modDate = new Date();
-      const testDate = new Date(modDate.getTime() - 10 * 24 * 60 * 60 * 1000); // 10 days ago
-      const score = calculateHealthScore(10, 0, 0, testDate.toISOString(), modDate.toISOString());
-      expect(score).toBeLessThan(100);
-    });
-
-    it('floors score at 0', () => {
-      const score = calculateHealthScore(0, 10, 10, null, null);
-      expect(score).toBeGreaterThanOrEqual(0);
-    });
-
-    it('combines multiple risk factors', () => {
-      const score = calculateHealthScore(
-        5,  // passing
-        3,  // 3 failing = -30
-        5,  // 5 modifications = -25
-        null,
-        null
-      );
-      expect(score).toBeLessThan(50);
-    });
-  });
-
-  describe('trackModification', () => {
-    it('creates new feature health record on first modification', () => {
-      trackModification(db, 'feature-auth');
-
-      const feature = db.prepare('SELECT * FROM feature_health WHERE feature_key = ?').get('feature-auth') as Record<string, unknown>;
-      expect(feature).toBeDefined();
-      expect(feature.modifications_since_test).toBe(1);
-      expect(feature.health_score).toBe(70); // Default for new feature with 1 modification
-    });
-
-    it('increments modifications for existing feature', () => {
-      // Create initial feature
-      db.prepare(`
-        INSERT INTO feature_health (feature_key, tests_passing, tests_failing, modifications_since_test, health_score)
-        VALUES (?, ?, ?, ?, ?)
-      `).run('feature-orders', 10, 0, 0, 100);
-
-      trackModification(db, 'feature-orders');
-
-      const feature = db.prepare('SELECT * FROM feature_health WHERE feature_key = ?').get('feature-orders') as Record<string, unknown>;
-      expect(feature.modifications_since_test).toBe(1);
-      expect(feature.health_score).toBeLessThan(100);
-    });
-
-    it('updates last_modified timestamp', () => {
-      trackModification(db, 'feature-products');
-
-      const feature = db.prepare('SELECT last_modified FROM feature_health WHERE feature_key = ?').get('feature-products') as { last_modified: string };
-      expect(feature.last_modified).toBeTruthy();
-    });
-  });
-
-  describe('recordTestResult', () => {
-    it('creates new feature health record with test results', () => {
-      recordTestResult(db, 'feature-auth', 15, 2);
-
-      const feature = db.prepare('SELECT * FROM feature_health WHERE feature_key = ?').get('feature-auth') as Record<string, unknown>;
-      expect(feature).toBeDefined();
-      expect(feature.tests_passing).toBe(15);
-      expect(feature.tests_failing).toBe(2);
-      expect(feature.modifications_since_test).toBe(0);
-    });
-
-    it('updates existing feature with test results', () => {
-      // Create feature with modifications
-      db.prepare(`
-        INSERT INTO feature_health (feature_key, modifications_since_test, health_score)
-        VALUES (?, ?, ?)
-      `).run('feature-orders', 5, 75);
-
-      recordTestResult(db, 'feature-orders', 20, 1);
-
-      const feature = db.prepare('SELECT * FROM feature_health WHERE feature_key = ?').get('feature-orders') as Record<string, unknown>;
-      expect(feature.tests_passing).toBe(20);
-      expect(feature.tests_failing).toBe(1);
-      expect(feature.modifications_since_test).toBe(0); // Reset after test
-    });
-
-    it('updates last_tested timestamp', () => {
-      recordTestResult(db, 'feature-products', 10, 0);
-
-      const feature = db.prepare('SELECT last_tested FROM feature_health WHERE feature_key = ?').get('feature-products') as { last_tested: string };
-      expect(feature.last_tested).toBeTruthy();
-    });
-
-    it('calculates test coverage percentage', () => {
-      recordTestResult(db, 'feature-auth', 15, 5);
-
-      const feature = db.prepare('SELECT test_coverage_pct FROM feature_health WHERE feature_key = ?').get('feature-auth') as { test_coverage_pct: number };
-      expect(feature.test_coverage_pct).toBe(75); // 15 / (15 + 5) = 75%
-    });
-
-    it('handles all passing tests', () => {
-      recordTestResult(db, 'feature-healthy', 20, 0);
-
-      const feature = db.prepare('SELECT * FROM feature_health WHERE feature_key = ?').get('feature-healthy') as Record<string, unknown>;
-      expect(feature.health_score).toBe(100);
-      expect(feature.test_coverage_pct).toBe(100);
-    });
-  });
-
-  describe('handleRegressionToolCall', () => {
-    it('handles feature_health with no data', () => {
-      const result = handleRegressionToolCall('massu_feature_health', {}, db);
-      const text = result.content[0].text;
-      expect(text).toContain('No feature health data available');
-    });
-
-    it('handles feature_health with features', () => {
-      db.prepare(`
-        INSERT INTO feature_health (feature_key, health_score, tests_passing, tests_failing, modifications_since_test)
-        VALUES (?, ?, ?, ?, ?)
-      `).run('feature-auth', 85, 10, 1, 2);
-
-      db.prepare(`
-        INSERT INTO feature_health (feature_key, health_score, tests_passing, tests_failing, modifications_since_test)
-        VALUES (?, ?, ?, ?, ?)
-      `).run('feature-orders', 60, 5, 3, 5);
-
-      const result = handleRegressionToolCall('massu_feature_health', {}, db);
-      const text = result.content[0].text;
-      expect(text).toContain('Feature Health Dashboard');
-      expect(text).toContain('feature-auth');
-      expect(text).toContain('feature-orders');
-      expect(text).toContain('85');
-      expect(text).toContain('60');
-    });
-
-    it('handles feature_health with unhealthy_only filter', () => {
-      db.prepare(`
-        INSERT INTO feature_health (feature_key, health_score, tests_passing, tests_failing)
-        VALUES (?, ?, ?, ?)
-      `).run('feature-healthy', 95, 20, 0);
-
-      db.prepare(`
-        INSERT INTO feature_health (feature_key, health_score, tests_passing, tests_failing)
-        VALUES (?, ?, ?, ?)
-      `).run('feature-unhealthy', 45, 5, 5);
-
-      const result = handleRegressionToolCall('massu_feature_health', { unhealthy_only: true }, db);
-      const text = result.content[0].text;
-      expect(text).toContain('feature-unhealthy');
-      expect(text).not.toContain('feature-healthy');
-    });
-
-    it('handles regression_risk with no modifications', () => {
-      const result = handleRegressionToolCall('massu_regression_risk', {}, db);
-      const text = result.content[0].text;
-      expect(text).toContain('No features have been modified');
-    });
-
-    it('handles regression_risk and categorizes by risk level', () => {
-      db.prepare(`
-        INSERT INTO feature_health (feature_key, health_score, modifications_since_test)
-        VALUES (?, ?, ?)
-      `).run('feature-critical', 30, 5);
-
-      db.prepare(`
-        INSERT INTO feature_health (feature_key, health_score, modifications_since_test)
-        VALUES (?, ?, ?)
-      `).run('feature-medium', 65, 3);
-
-      db.prepare(`
-        INSERT INTO feature_health (feature_key, health_score, modifications_since_test)
-        VALUES (?, ?, ?)
-      `).run('feature-low', 85, 1);
-
-      const result = handleRegressionToolCall('massu_regression_risk', {}, db);
-      const text = result.content[0].text;
-      expect(text).toContain('Regression Risk Assessment');
-      expect(text).toContain('HIGH RISK');
-      expect(text).toContain('Medium Risk');
-      expect(text).toContain('Low Risk');
-      expect(text).toContain('feature-critical');
-      expect(text).toContain('feature-medium');
-      expect(text).toContain('feature-low');
-    });
-
-    it('handles unknown tool name', () => {
-      const result = handleRegressionToolCall('massu_regression_unknown', {}, db);
-      const text = result.content[0].text;
-      expect(text).toContain('Unknown regression tool');
-    });
-  });
-});

package/src/__tests__/rules.test.ts

@@ -1,87 +0,0 @@
-// Copyright (c) 2026 Massu. All rights reserved.
-// Licensed under BSL 1.1 - see LICENSE file for details.
-
-import { describe, it, expect, vi } from 'vitest';
-import { matchRules, globMatch } from '../rules.ts';
-
-// Mock config to avoid interference from parallel tests that change process.cwd()
-// Rules match massu.config.yaml content
-vi.mock('../config.ts', () => ({
-  getConfig: () => ({
-    toolPrefix: 'massu',
-    rules: [
-      {
-        pattern: 'src/**/*.ts',
-        rules: [
-          'Use ESM imports (import/export), not CommonJS (require/module.exports)',
-          'All database operations go through better-sqlite3',
-        ],
-      },
-      {
-        pattern: 'src/hooks/**/*.ts',
-        rules: [
-          'Hooks receive JSON on stdin, output JSON on stdout',
-          'Hooks must exit within 5 seconds',
-          'Never import heavy dependencies - hooks must be fast',
-        ],
-      },
-    ],
-  }),
-}));
-
-describe('globMatch', () => {
-  it('matches simple glob patterns', () => {
-    expect(globMatch('src/server/api/routers/orders.ts', 'src/server/api/routers/**')).toBe(true);
-    expect(globMatch('src/components/orders/OrderCard.tsx', 'src/components/**')).toBe(true);
-    expect(globMatch('src/app/orders/page.tsx', 'src/app/**/page.tsx')).toBe(true);
-  });
-
-  it('matches wildcard table name patterns', () => {
-    expect(globMatch('src/server/api/routers/unified_products.ts', '**/unified_products**')).toBe(true);
-    expect(globMatch('src/lib/unified_products/helpers.ts', '**/unified_products**')).toBe(true);
-  });
-
-  it('rejects non-matching paths', () => {
-    expect(globMatch('src/lib/utils.ts', 'src/server/api/routers/**')).toBe(false);
-    expect(globMatch('package.json', 'src/components/**')).toBe(false);
-  });
-
-  it('matches middleware.ts exactly', () => {
-    expect(globMatch('src/middleware.ts', 'src/middleware.ts')).toBe(true);
-    expect(globMatch('src/other-middleware.ts', 'src/middleware.ts')).toBe(false);
-  });
-});
-
-describe('matchRules', () => {
-  // These tests validate against Massu's own config rules:
-  //   src/**/*.ts -> ESM imports, better-sqlite3
-  //   src/hooks/**/*.ts -> stdin/stdout JSON, exit within 5 seconds, no heavy deps
-
-  it('returns rules for TypeScript source files', () => {
-    const rules = matchRules('src/config.ts');
-    expect(rules.length).toBeGreaterThan(0);
-    const allRuleTexts = rules.flatMap(r => r.rules);
-    expect(allRuleTexts.some(r => r.includes('ESM'))).toBe(true);
-  });
-
-  it('returns hook-specific rules for hook files', () => {
-    const rules = matchRules('src/hooks/post-edit-context.ts');
-    // Should match both src/**/*.ts AND src/hooks/**/*.ts patterns
-    expect(rules.length).toBeGreaterThanOrEqual(2);
-    const allRuleTexts = rules.flatMap(r => r.rules);
-    expect(allRuleTexts.some(r => r.includes('stdin'))).toBe(true);
-    expect(allRuleTexts.some(r => r.includes('5 seconds'))).toBe(true);
-  });
-
-  it('returns no rules for non-matching paths', () => {
-    const rules = matchRules('package.json');
-    expect(rules.length).toBe(0);
-  });
-
-  it('returns rules for deeply nested src files', () => {
-    const rules = matchRules('src/deep/nested/module.ts');
-    expect(rules.length).toBeGreaterThan(0);
-    const allRuleTexts = rules.flatMap(r => r.rules);
-    expect(allRuleTexts.some(r => r.includes('better-sqlite3'))).toBe(true);
-  });
-});