@soleri/core 9.0.3 → 9.2.0

package/src/__tests__/claudemd.test.ts

@@ -1,282 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { join } from 'node:path';
-import { mkdtempSync, rmSync, readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import {
-  composeCLAUDEmd,
-  OPEN_MARKER,
-  CLOSE_MARKER,
-  USER_ZONE_OPEN,
-  USER_ZONE_CLOSE,
-} from '../claudemd/compose.js';
-import {
-  injectCLAUDEmd,
-  removeCLAUDEmd,
-  hasCLAUDEmdBlock,
-  extractUserZone,
-} from '../claudemd/inject.js';
-import type { AgentMeta } from '../claudemd/types.js';
-import type { FacadeConfig } from '../facades/types.js';
-
-const testAgent: AgentMeta = {
-  id: 'test-agent',
-  name: 'TestAgent',
-  activationPhrase: 'Hello, TestAgent!',
-  deactivationPhrase: 'Goodbye, TestAgent!',
-  activateCommand: 'test-agent_core op:activate params:{ projectPath: "." }',
-  deactivateCommand: 'test-agent_core op:activate params:{ deactivate: true }',
-};
-
-const testFacades: FacadeConfig[] = [
-  {
-    name: 'test-agent_core',
-    description: 'Core facade',
-    ops: [
-      { name: 'health', description: 'Health check', auth: 'read', handler: async () => ({}) },
-      { name: 'search', description: 'Search vault', auth: 'read', handler: async () => ({}) },
-      { name: 'capture', description: 'Capture', auth: 'write', handler: async () => ({}) },
-    ],
-  },
-  {
-    name: 'test-agent_design',
-    description: 'Design facade',
-    ops: [
-      { name: 'check_contrast', description: 'Contrast', auth: 'read', handler: async () => ({}) },
-      { name: 'validate_token', description: 'Validate', auth: 'read', handler: async () => ({}) },
-    ],
-  },
-];
-
-describe('composeCLAUDEmd', () => {
-  it('produces content wrapped in versioned markers', () => {
-    const result = composeCLAUDEmd(testAgent, testFacades);
-    expect(result).toContain(OPEN_MARKER);
-    expect(result).toContain(CLOSE_MARKER);
-    expect(result).toContain('v1');
-  });
-
-  it('includes activation phrases', () => {
-    const result = composeCLAUDEmd(testAgent, testFacades);
-    expect(result).toContain('Hello, TestAgent!');
-    expect(result).toContain('Goodbye, TestAgent!');
-  });
-
-  it('includes session start protocol', () => {
-    const result = composeCLAUDEmd(testAgent, testFacades);
-    expect(result).toContain('Session Start Protocol');
-    expect(result).toContain('test-agent_core op:register');
-  });
-
-  it('generates facade reference table', () => {
-    const result = composeCLAUDEmd(testAgent, testFacades);
-    expect(result).toContain('| Facade | Key Ops |');
-    expect(result).toContain('`test-agent_core`');
-    expect(result).toContain('`test-agent_design`');
-    expect(result).toContain('`health`');
-    expect(result).toContain('`check_contrast`');
-  });
-
-  it('includes global instructions sorted by priority', () => {
-    const agent: AgentMeta = {
-      ...testAgent,
-      globalInstructions: [
-        { heading: 'Low Priority', content: 'Come last', priority: 90 },
-        { heading: 'High Priority', content: 'Come first', priority: 10 },
-      ],
-    };
-    const result = composeCLAUDEmd(agent, testFacades);
-    const highIdx = result.indexOf('High Priority');
-    const lowIdx = result.indexOf('Low Priority');
-    expect(highIdx).toBeLessThan(lowIdx);
-  });
-
-  it('includes facade behavioral rules', () => {
-    const instructions = new Map([
-      [
-        'test-agent_core',
-        {
-          heading: 'Planning',
-          rules: ['Always plan before coding', 'Wait for approval'],
-          priority: 10,
-        },
-      ],
-    ]);
-    const result = composeCLAUDEmd(testAgent, testFacades, { facadeInstructions: instructions });
-    expect(result).toContain('## Planning');
-    expect(result).toContain('- Always plan before coding');
-    expect(result).toContain('- Wait for approval');
-  });
-
-  it('includes user-safe zone when requested', () => {
-    const result = composeCLAUDEmd(testAgent, testFacades, { includeUserZone: true });
-    expect(result).toContain(USER_ZONE_OPEN);
-    expect(result).toContain(USER_ZONE_CLOSE);
-  });
-});
-
-describe('injectCLAUDEmd', () => {
-  let tempDir: string;
-  let filePath: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'soleri-claudemd-'));
-    filePath = join(tempDir, 'CLAUDE.md');
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it('creates a new file if none exists', () => {
-    const block = composeCLAUDEmd(testAgent, testFacades);
-    const result = injectCLAUDEmd(filePath, block);
-    expect(result.success).toBe(true);
-    expect(result.action).toBe('injected');
-    const content = readFileSync(filePath, 'utf-8');
-    expect(content).toContain(OPEN_MARKER);
-  });
-
-  it('appends to existing file without markers', () => {
-    writeFileSync(filePath, '# My Project\n\nSome user content.\n');
-    const block = composeCLAUDEmd(testAgent, testFacades);
-    const result = injectCLAUDEmd(filePath, block);
-    expect(result.action).toBe('injected');
-    const content = readFileSync(filePath, 'utf-8');
-    expect(content).toContain('# My Project');
-    expect(content).toContain(OPEN_MARKER);
-  });
-
-  it('replaces existing block', () => {
-    const block1 = composeCLAUDEmd(testAgent, testFacades);
-    writeFileSync(filePath, `# Header\n\n${block1}\n\n# Footer\n`);
-
-    const newAgent = { ...testAgent, name: 'UpdatedAgent' };
-    const block2 = composeCLAUDEmd(newAgent, testFacades);
-    const result = injectCLAUDEmd(filePath, block2);
-
-    expect(result.action).toBe('replaced');
-    expect(result.diffDetected).toBe(true);
-    const content = readFileSync(filePath, 'utf-8');
-    expect(content).toContain('UpdatedAgent');
-    expect(content).not.toContain('TestAgent Mode');
-    expect(content).toContain('# Header');
-    expect(content).toContain('# Footer');
-  });
-
-  it('skips write when content is identical', () => {
-    const block = composeCLAUDEmd(testAgent, testFacades);
-    writeFileSync(filePath, block);
-    const result = injectCLAUDEmd(filePath, block);
-    expect(result.action).toBe('skipped');
-    expect(result.diffDetected).toBe(false);
-  });
-
-  it('preserves user-safe zone content on regeneration', () => {
-    const block1 = composeCLAUDEmd(testAgent, testFacades, { includeUserZone: true });
-    // Simulate user adding custom content inside the zone
-    const customContent = 'My custom instructions here';
-    const withCustom = block1.replace(
-      `${USER_ZONE_OPEN}\n\n${USER_ZONE_CLOSE}`,
-      `${USER_ZONE_OPEN}\n${customContent}\n${USER_ZONE_CLOSE}`,
-    );
-    writeFileSync(filePath, withCustom);
-
-    // Regenerate — should preserve user content
-    const block2 = composeCLAUDEmd(testAgent, testFacades, { includeUserZone: true });
-    const result = injectCLAUDEmd(filePath, block2);
-    expect(result.success).toBe(true);
-    const content = readFileSync(filePath, 'utf-8');
-    expect(content).toContain(customContent);
-  });
-
-  it('migrates legacy unversioned markers', () => {
-    const legacyBlock = '<!-- agent:mode -->\n\nOld content\n\n<!-- /agent:mode -->';
-    writeFileSync(filePath, `# Header\n\n${legacyBlock}\n`);
-
-    const block = composeCLAUDEmd(testAgent, testFacades);
-    const result = injectCLAUDEmd(filePath, block);
-    expect(result.action).toBe('replaced');
-    const content = readFileSync(filePath, 'utf-8');
-    expect(content).toContain(OPEN_MARKER); // v1 marker
-    expect(content).not.toContain('Old content');
-  });
-});
-
-describe('removeCLAUDEmd', () => {
-  let tempDir: string;
-  let filePath: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'soleri-claudemd-'));
-    filePath = join(tempDir, 'CLAUDE.md');
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it('removes agent block and preserves surrounding content', () => {
-    const block = composeCLAUDEmd(testAgent, testFacades);
-    writeFileSync(filePath, `# Header\n\n${block}\n\n# Footer\n`);
-    const result = removeCLAUDEmd(filePath);
-    expect(result.action).toBe('removed');
-    const content = readFileSync(filePath, 'utf-8');
-    expect(content).toContain('# Header');
-    expect(content).toContain('# Footer');
-    expect(content).not.toContain(OPEN_MARKER);
-  });
-
-  it('returns not_present when no block exists', () => {
-    writeFileSync(filePath, '# Just a file\n');
-    expect(removeCLAUDEmd(filePath).action).toBe('not_present');
-  });
-
-  it('returns not_present for missing file', () => {
-    expect(removeCLAUDEmd(filePath).action).toBe('not_present');
-  });
-});
-
-describe('hasCLAUDEmdBlock', () => {
-  let tempDir: string;
-  let filePath: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'soleri-claudemd-'));
-    filePath = join(tempDir, 'CLAUDE.md');
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it('returns true when block exists', () => {
-    const block = composeCLAUDEmd(testAgent, testFacades);
-    writeFileSync(filePath, block);
-    expect(hasCLAUDEmdBlock(filePath)).toBe(true);
-  });
-
-  it('returns false when no block', () => {
-    writeFileSync(filePath, '# No agent block\n');
-    expect(hasCLAUDEmdBlock(filePath)).toBe(false);
-  });
-
-  it('returns false for missing file', () => {
-    expect(hasCLAUDEmdBlock(filePath)).toBe(false);
-  });
-});
-
-describe('extractUserZone', () => {
-  it('extracts content between user zone markers', () => {
-    const content = `Some stuff\n${USER_ZONE_OPEN}\nMy custom stuff\n${USER_ZONE_CLOSE}\nMore`;
-    expect(extractUserZone(content)).toBe('My custom stuff');
-  });
-
-  it('returns null for empty zone', () => {
-    const content = `${USER_ZONE_OPEN}\n\n${USER_ZONE_CLOSE}`;
-    expect(extractUserZone(content)).toBeNull();
-  });
-
-  it('returns null when no zone markers', () => {
-    expect(extractUserZone('just text')).toBeNull();
-  });
-});

package/src/__tests__/content-hash.test.ts

@@ -1,60 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { computeContentHash } from '../vault/content-hash.js';
-
-describe('computeContentHash', () => {
-  const base = {
-    type: 'pattern',
-    domain: 'testing',
-    title: 'Test Pattern',
-    description: 'A test pattern.',
-    tags: ['a', 'b'],
-  };
-
-  it('returns 40-char hex string', () => {
-    const hash = computeContentHash(base);
-    expect(hash).toMatch(/^[0-9a-f]{40}$/);
-  });
-
-  it('is deterministic', () => {
-    expect(computeContentHash(base)).toBe(computeContentHash(base));
-  });
-
-  it('normalizes tag order', () => {
-    const a = computeContentHash({ ...base, tags: ['b', 'a'] });
-    const b = computeContentHash({ ...base, tags: ['a', 'b'] });
-    expect(a).toBe(b);
-  });
-
-  it('normalizes whitespace', () => {
-    const a = computeContentHash(base);
-    const b = computeContentHash({
-      ...base,
-      title: '  Test Pattern  ',
-      description: '  A test pattern.  ',
-    });
-    expect(a).toBe(b);
-  });
-
-  it('normalizes domain case', () => {
-    const a = computeContentHash(base);
-    const b = computeContentHash({ ...base, domain: 'TESTING' });
-    expect(a).toBe(b);
-  });
-
-  it('different content produces different hash', () => {
-    const a = computeContentHash(base);
-    const b = computeContentHash({ ...base, title: 'Different' });
-    expect(a).not.toBe(b);
-  });
-
-  it('handles missing optional fields', () => {
-    const hash = computeContentHash({ type: 'rule', domain: 'd', title: 't', description: 'd' });
-    expect(hash).toMatch(/^[0-9a-f]{40}$/);
-  });
-
-  it('example and counterExample affect hash', () => {
-    const a = computeContentHash({ ...base, example: 'do this' });
-    const b = computeContentHash({ ...base, example: 'do that' });
-    expect(a).not.toBe(b);
-  });
-});

package/src/__tests__/context-engine.test.ts

@@ -1,251 +0,0 @@
-/**
- * Context Engine Tests — entity extraction, knowledge retrieval, confidence scoring.
- */
-
-import { describe, test, expect, beforeEach } from 'vitest';
-import { Vault } from '../vault/vault.js';
-import { Brain } from '../brain/brain.js';
-import { BrainIntelligence } from '../brain/intelligence.js';
-import { ContextEngine } from '../context/context-engine.js';
-
-describe('ContextEngine', () => {
-  let vault: Vault;
-  let brain: Brain;
-  let intelligence: BrainIntelligence;
-  let engine: ContextEngine;
-
-  beforeEach(() => {
-    vault = new Vault(':memory:');
-    brain = new Brain(vault);
-    intelligence = new BrainIntelligence(vault, brain);
-    engine = new ContextEngine(vault, brain, intelligence, null);
-  });
-
-  // ─── Entity Extraction ───────────────────────────────────────────
-
-  describe('extractEntities', () => {
-    test('extracts file paths', () => {
-      const result = engine.extractEntities('Fix the bug in src/vault/vault.ts');
-      const files = result.byType.file ?? [];
-      expect(files.length).toBeGreaterThan(0);
-      expect(files.some((f) => f.value.includes('vault.ts'))).toBe(true);
-    });
-
-    test('extracts function calls', () => {
-      const result = engine.extractEntities('The search() method returns wrong results');
-      const functions = result.byType.function ?? [];
-      expect(functions.length).toBeGreaterThan(0);
-      expect(functions.some((f) => f.value === 'search()')).toBe(true);
-    });
-
-    test('extracts domain keywords', () => {
-      const result = engine.extractEntities('Improve accessibility and performance');
-      const domains = result.byType.domain ?? [];
-      expect(domains.length).toBe(2);
-      expect(domains.some((d) => d.value === 'accessibility')).toBe(true);
-      expect(domains.some((d) => d.value === 'performance')).toBe(true);
-    });
-
-    test('extracts action verbs', () => {
-      const result = engine.extractEntities('Create a new component and test it');
-      const actions = result.byType.action ?? [];
-      expect(actions.some((a) => a.value === 'create')).toBe(true);
-      expect(actions.some((a) => a.value === 'test')).toBe(true);
-    });
-
-    test('extracts technologies', () => {
-      const result = engine.extractEntities('Build a React component with TypeScript');
-      const techs = result.byType.technology ?? [];
-      expect(techs.some((t) => t.value === 'react')).toBe(true);
-      expect(techs.some((t) => t.value === 'typescript')).toBe(true);
-    });
-
-    test('deduplicates entities', () => {
-      const result = engine.extractEntities('Fix the fix for the fix');
-      const actions = result.byType.action ?? [];
-      const fixActions = actions.filter((a) => a.value === 'fix');
-      expect(fixActions.length).toBe(1);
-    });
-
-    test('filters stop patterns', () => {
-      const result = engine.extractEntities('This is a real-time built-in feature');
-      const patterns = result.byType.pattern ?? [];
-      expect(patterns.some((p) => p.value === 'real-time')).toBe(false);
-      expect(patterns.some((p) => p.value === 'built-in')).toBe(false);
-    });
-
-    test('returns empty for empty prompt', () => {
-      const result = engine.extractEntities('');
-      expect(result.entities.length).toBe(0);
-    });
-
-    test('groups entities by type', () => {
-      const result = engine.extractEntities('Create a React component in src/app.tsx for security');
-      expect(result.byType.action).toBeDefined();
-      expect(result.byType.technology).toBeDefined();
-      expect(result.byType.file).toBeDefined();
-      expect(result.byType.domain).toBeDefined();
-    });
-  });
-
-  // ─── Knowledge Retrieval ─────────────────────────────────────────
-
-  describe('retrieveKnowledge', () => {
-    test('retrieves from vault FTS', async () => {
-      vault.seed([
-        {
-          id: 'p1',
-          type: 'pattern',
-          domain: 'design',
-          title: 'Button component pattern',
-          severity: 'suggestion',
-          description: 'Use semantic HTML for buttons',
-          tags: ['design', 'component'],
-        },
-      ]);
-
-      // Use single term for FTS5 compatibility
-      const result = await engine.retrieveKnowledge('button');
-      expect(result.vaultHits).toBeGreaterThan(0);
-      expect(result.items.length).toBeGreaterThan(0);
-      expect(result.items[0].source).toBe('vault');
-    });
-
-    test('returns empty when vault has no matches', async () => {
-      const result = await engine.retrieveKnowledge('xyzzy nonexistent query');
-      expect(result.items.length).toBe(0);
-      expect(result.vaultHits).toBe(0);
-    });
-
-    test('filters by domain', async () => {
-      vault.seed([
-        {
-          id: 'p1',
-          type: 'pattern',
-          domain: 'design',
-          title: 'Design pattern one',
-          severity: 'suggestion',
-          description: 'A design domain pattern',
-          tags: ['design'],
-        },
-        {
-          id: 'p2',
-          type: 'pattern',
-          domain: 'security',
-          title: 'Security pattern one',
-          severity: 'warning',
-          description: 'A security domain pattern',
-          tags: ['security'],
-        },
-      ]);
-
-      // Search for "pattern" (exists in both entries) filtered to design domain
-      const result = await engine.retrieveKnowledge('pattern', 'design');
-      expect(result.vaultHits).toBe(1);
-      expect(result.items.length).toBeGreaterThan(0);
-      expect(result.items[0].domain).toBe('design');
-    });
-  });
-
-  // ─── Context Analysis ────────────────────────────────────────────
-
-  describe('analyze', () => {
-    test('returns full context analysis', async () => {
-      vault.seed([
-        {
-          id: 'r1',
-          type: 'rule',
-          domain: 'accessibility',
-          title: 'All buttons must have labels',
-          severity: 'critical',
-          description: 'Screen readers require button labels for navigation',
-          tags: ['accessibility', 'button'],
-        },
-      ]);
-
-      const result = await engine.analyze('Fix the accessibility issue with buttons');
-
-      expect(result.prompt).toBe('Fix the accessibility issue with buttons');
-      expect(result.entities.entities.length).toBeGreaterThan(0);
-      expect(result.confidence).toBeGreaterThan(0);
-      expect(result.confidenceLevel).toBeDefined();
-      expect(result.detectedDomains).toContain('accessibility');
-      expect(result.processingTimeMs).toBeGreaterThanOrEqual(0);
-    });
-
-    test('detects domains from entities and knowledge', async () => {
-      vault.seed([
-        {
-          id: 'r1',
-          type: 'rule',
-          domain: 'performance',
-          title: 'Avoid N+1 queries',
-          severity: 'warning',
-          description: 'Batch database queries to avoid N+1 problems',
-          tags: ['performance', 'database'],
-        },
-      ]);
-
-      const result = await engine.analyze('Optimize the performance of database queries');
-      expect(result.detectedDomains).toContain('performance');
-    });
-
-    test('low confidence for vague prompts', async () => {
-      const result = await engine.analyze('do something');
-      expect(result.confidenceLevel).toBe('low');
-    });
-
-    test('higher confidence with entities and knowledge', async () => {
-      vault.seed([
-        {
-          id: 'r1',
-          type: 'pattern',
-          domain: 'testing',
-          title: 'Unit test best practices',
-          severity: 'suggestion',
-          description: 'Write focused unit tests that test one thing',
-          tags: ['testing'],
-        },
-      ]);
-
-      const result = await engine.analyze(
-        'Create unit tests for the search() function in src/vault/vault.ts with TypeScript',
-      );
-      expect(result.confidence).toBeGreaterThan(0.4);
-      expect(result.entities.entities.length).toBeGreaterThan(3);
-    });
-
-    test('includes processing time', async () => {
-      const result = await engine.analyze('test query');
-      expect(typeof result.processingTimeMs).toBe('number');
-      expect(result.processingTimeMs).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  // ─── Configuration ───────────────────────────────────────────────
-
-  describe('configuration', () => {
-    test('respects custom config', async () => {
-      const customEngine = new ContextEngine(vault, brain, intelligence, {
-        vaultSearchLimit: 2,
-        minScoreThreshold: 0.9,
-      });
-
-      vault.seed(
-        Array.from({ length: 10 }, (_, i) => ({
-          id: `entry-${i}`,
-          type: 'pattern' as const,
-          domain: 'general',
-          title: `Pattern ${i} for testing`,
-          severity: 'suggestion' as const,
-          description: `Description for pattern ${i}`,
-          tags: ['general'],
-        })),
-      );
-
-      const result = await customEngine.retrieveKnowledge('pattern testing');
-      // High threshold filters out low-score items
-      expect(result.items.every((i) => i.score >= 0.9)).toBe(true);
-    });
-  });
-});