@soleri/core 9.0.4 → 9.3.0

package/src/curator/quality-gate.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect, vi } from 'vitest';
+import { evaluateQuality } from './quality-gate.js';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+import type { LLMClient } from '../llm/llm-client.js';
+
+function makeEntry(overrides: Partial<IntelligenceEntry> = {}): IntelligenceEntry {
+  return {
+    id: overrides.id ?? 'test-1',
+    type: overrides.type ?? 'pattern',
+    domain: overrides.domain ?? 'testing',
+    title: overrides.title ?? 'Test Pattern',
+    severity: overrides.severity ?? 'warning',
+    description: overrides.description ?? 'A test pattern.',
+    tags: overrides.tags ?? ['testing'],
+  };
+}
+
+function mockLLM(response: string): LLMClient {
+  return {
+    complete: vi.fn().mockResolvedValue({ text: response }),
+  } as unknown as LLMClient;
+}
+
+describe('evaluateQuality', () => {
+  it('returns ACCEPT fallback when llm is null', async () => {
+    const result = await evaluateQuality(makeEntry(), null);
+    expect(result.evaluated).toBe(false);
+    expect(result.verdict).toBe('ACCEPT');
+    expect(result.overallScore).toBe(50);
+    expect(result.reasoning).toContain('LLM unavailable');
+  });
+
+  it('returns ACCEPT for high-quality entry', async () => {
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'ACCEPT',
+        overallScore: 85,
+        scores: {
+          novelty: 80,
+          actionability: 90,
+          specificity: 85,
+          relevance: 80,
+          informationDensity: 90,
+        },
+        reasoning: 'High quality entry with specific guidance.',
+      }),
+    );
+
+    const result = await evaluateQuality(makeEntry(), llm);
+    expect(result.evaluated).toBe(true);
+    expect(result.verdict).toBe('ACCEPT');
+    expect(result.overallScore).toBe(85);
+  });
+
+  it('returns REJECT for low-quality entry', async () => {
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'REJECT',
+        overallScore: 30,
+        scores: {
+          novelty: 10,
+          actionability: 30,
+          specificity: 40,
+          relevance: 50,
+          informationDensity: 20,
+        },
+        reasoning: 'Too generic.',
+        rejectReasons: ['Low novelty', 'Not actionable'],
+      }),
+    );
+
+    const result = await evaluateQuality(makeEntry(), llm);
+    expect(result.evaluated).toBe(true);
+    expect(result.verdict).toBe('REJECT');
+    expect(result.overallScore).toBe(30);
+    expect(result.rejectReasons).toEqual(['Low novelty', 'Not actionable']);
+  });
+
+  it('returns fallback with error on LLM failure', async () => {
+    const llm = {
+      complete: vi.fn().mockRejectedValue(new Error('timeout')),
+    } as unknown as LLMClient;
+
+    const result = await evaluateQuality(makeEntry(), llm);
+    expect(result.evaluated).toBe(false);
+    expect(result.verdict).toBe('ACCEPT');
+    expect(result.error).toBe('timeout');
+  });
+
+  it('returns fallback with error on invalid JSON', async () => {
+    const llm = mockLLM('invalid json response');
+    const result = await evaluateQuality(makeEntry(), llm);
+    expect(result.evaluated).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  it('handles missing fields in LLM response', async () => {
+    const llm = mockLLM(JSON.stringify({ verdict: 'ACCEPT' }));
+    const result = await evaluateQuality(makeEntry(), llm);
+    expect(result.evaluated).toBe(true);
+    expect(result.overallScore).toBe(50);
+    expect(result.reasoning).toBe('');
+  });
+
+  it('normalizes non-REJECT verdict to ACCEPT', async () => {
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'MAYBE',
+        overallScore: 60,
+        scores: {
+          novelty: 60,
+          actionability: 60,
+          specificity: 60,
+          relevance: 60,
+          informationDensity: 60,
+        },
+        reasoning: 'Borderline entry.',
+      }),
+    );
+
+    const result = await evaluateQuality(makeEntry(), llm);
+    expect(result.verdict).toBe('ACCEPT');
+  });
+
+  it('includes optional entry fields in prompt', async () => {
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'ACCEPT',
+        overallScore: 70,
+        scores: {
+          novelty: 70,
+          actionability: 70,
+          specificity: 70,
+          relevance: 70,
+          informationDensity: 70,
+        },
+        reasoning: 'OK.',
+      }),
+    );
+
+    const entry = makeEntry();
+    entry.why = 'Because security matters';
+    entry.example = 'jwt.verify(token)';
+    entry.context = 'Node.js backend';
+
+    await evaluateQuality(entry, llm);
+
+    const call = (llm.complete as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    expect(call.userPrompt).toContain('Because security matters');
+    expect(call.userPrompt).toContain('jwt.verify(token)');
+    expect(call.userPrompt).toContain('Node.js backend');
+  });
+
+  it('uses low temperature for consistent scoring', async () => {
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'ACCEPT',
+        overallScore: 70,
+        scores: {
+          novelty: 70,
+          actionability: 70,
+          specificity: 70,
+          relevance: 70,
+          informationDensity: 70,
+        },
+        reasoning: 'OK.',
+      }),
+    );
+
+    await evaluateQuality(makeEntry(), llm);
+
+    const call = (llm.complete as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    expect(call.temperature).toBe(0.1);
+  });
+});

package/src/curator/schema.ts

@@ -0,0 +1,65 @@
+/**
+ * Curator Schema — DDL for curator tables.
+ */
+
+import type { PersistenceProvider } from '../persistence/types.js';
+
+export const CURATOR_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS curator_entry_state (
+    entry_id TEXT PRIMARY KEY,
+    status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'stale', 'archived')),
+    confidence REAL NOT NULL DEFAULT 1.0,
+    source TEXT NOT NULL DEFAULT 'unknown' CHECK(source IN ('manual', 'capture', 'seed', 'unknown')),
+    last_groomed_at INTEGER,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE TABLE IF NOT EXISTS curator_tag_canonical (
+    tag TEXT PRIMARY KEY,
+    description TEXT,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE TABLE IF NOT EXISTS curator_tag_alias (
+    alias TEXT PRIMARY KEY,
+    canonical TEXT NOT NULL,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+    FOREIGN KEY (canonical) REFERENCES curator_tag_canonical(tag)
+  );
+
+  CREATE TABLE IF NOT EXISTS curator_changelog (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    action TEXT NOT NULL,
+    entry_id TEXT NOT NULL,
+    before_value TEXT,
+    after_value TEXT,
+    reason TEXT NOT NULL,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE TABLE IF NOT EXISTS curator_entry_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entry_id TEXT NOT NULL,
+    snapshot TEXT NOT NULL,
+    changed_by TEXT DEFAULT 'system',
+    change_reason TEXT,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE TABLE IF NOT EXISTS curator_contradictions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    pattern_id TEXT NOT NULL,
+    antipattern_id TEXT NOT NULL,
+    similarity REAL NOT NULL,
+    status TEXT NOT NULL DEFAULT 'open' CHECK(status IN ('open', 'resolved', 'dismissed')),
+    created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+    resolved_at INTEGER,
+    UNIQUE(pattern_id, antipattern_id)
+  );
+  CREATE INDEX IF NOT EXISTS idx_curator_state_status ON curator_entry_state(status);
+  CREATE INDEX IF NOT EXISTS idx_curator_changelog_entry ON curator_changelog(entry_id);
+`;
+
+export function initializeTables(provider: PersistenceProvider): void {
+  provider.execSql(CURATOR_SCHEMA);
+}

package/src/curator/tag-manager.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  normalizeTag,
+  normalizeTags,
+  normalizeAndDedup,
+  addTagAlias,
+  getCanonicalTags,
+  seedDefaultAliases,
+  DEFAULT_TAG_ALIASES,
+  type TagStore,
+} from './tag-manager.js';
+
+function mockTagStore(): TagStore {
+  const aliases = new Map<string, string>();
+  const canonicals = new Map<string, string | null>();
+
+  return {
+    getAlias: vi.fn((lower: string) => aliases.get(lower) ?? null),
+    insertCanonical: vi.fn((tag: string) => {
+      canonicals.set(tag, null);
+    }),
+    upsertAlias: vi.fn((alias: string, canonical: string) => {
+      aliases.set(alias, canonical);
+    }),
+    getCanonicalRows: vi.fn(() =>
+      Array.from(canonicals.entries()).map(([tag, description]) => ({
+        tag,
+        description,
+        alias_count: Array.from(aliases.values()).filter((c) => c === tag).length,
+      })),
+    ),
+    countTagUsage: vi.fn(() => 0),
+  };
+}
+
+describe('tag-manager', () => {
+  let store: TagStore;
+
+  beforeEach(() => {
+    store = mockTagStore();
+  });
+
+  describe('DEFAULT_TAG_ALIASES', () => {
+    it('exports expected alias count', () => {
+      expect(DEFAULT_TAG_ALIASES.length).toBe(13);
+    });
+
+    it('includes common aliases', () => {
+      const aliasMap = new Map(DEFAULT_TAG_ALIASES);
+      expect(aliasMap.get('a11y')).toBe('accessibility');
+      expect(aliasMap.get('ts')).toBe('typescript');
+      expect(aliasMap.get('js')).toBe('javascript');
+      expect(aliasMap.get('perf')).toBe('performance');
+    });
+  });
+
+  describe('normalizeTag', () => {
+    it('returns aliased result when store has alias', () => {
+      (store.getAlias as ReturnType<typeof vi.fn>).mockReturnValue('accessibility');
+      const result = normalizeTag('a11y', store);
+      expect(result).toEqual({ original: 'a11y', normalized: 'accessibility', wasAliased: true });
+    });
+
+    it('returns lowercased tag when no alias found', () => {
+      const result = normalizeTag('MyCustomTag', store);
+      expect(result).toEqual({
+        original: 'MyCustomTag',
+        normalized: 'mycustomtag',
+        wasAliased: false,
+      });
+    });
+
+    it('trims whitespace', () => {
+      const result = normalizeTag('  spaced  ', store);
+      expect(result.normalized).toBe('spaced');
+    });
+
+    it('lowercases before lookup', () => {
+      normalizeTag('A11Y', store);
+      expect(store.getAlias).toHaveBeenCalledWith('a11y');
+    });
+  });
+
+  describe('normalizeTags', () => {
+    it('normalizes each tag in the array', () => {
+      (store.getAlias as ReturnType<typeof vi.fn>)
+        .mockReturnValueOnce('accessibility')
+        .mockReturnValueOnce(null);
+      const results = normalizeTags(['a11y', 'custom'], store);
+      expect(results).toHaveLength(2);
+      expect(results[0].wasAliased).toBe(true);
+      expect(results[1].wasAliased).toBe(false);
+    });
+
+    it('returns empty array for empty input', () => {
+      expect(normalizeTags([], store)).toEqual([]);
+    });
+  });
+
+  describe('normalizeAndDedup', () => {
+    it('deduplicates after normalization', () => {
+      (store.getAlias as ReturnType<typeof vi.fn>)
+        .mockReturnValueOnce('styling') // css -> styling
+        .mockReturnValueOnce('styling'); // tailwind -> styling
+      const { results, dedupedTags, changed } = normalizeAndDedup(['css', 'tailwind'], store);
+      expect(results).toHaveLength(2);
+      expect(dedupedTags).toEqual(['styling']);
+      expect(changed).toBe(true);
+    });
+
+    it('reports changed=false when no aliases applied', () => {
+      const { changed } = normalizeAndDedup(['custom', 'other'], store);
+      expect(changed).toBe(false);
+    });
+
+    it('reports changed=true when any tag is aliased', () => {
+      (store.getAlias as ReturnType<typeof vi.fn>)
+        .mockReturnValueOnce('accessibility')
+        .mockReturnValueOnce(null);
+      const { changed } = normalizeAndDedup(['a11y', 'custom'], store);
+      expect(changed).toBe(true);
+    });
+  });
+
+  describe('addTagAlias', () => {
+    it('inserts canonical and upserts alias', () => {
+      addTagAlias('react', 'frontend', store);
+      expect(store.insertCanonical).toHaveBeenCalledWith('frontend');
+      expect(store.upsertAlias).toHaveBeenCalledWith('react', 'frontend');
+    });
+
+    it('lowercases and trims both alias and canonical', () => {
+      addTagAlias('  React  ', '  Frontend  ', store);
+      expect(store.insertCanonical).toHaveBeenCalledWith('frontend');
+      expect(store.upsertAlias).toHaveBeenCalledWith('react', 'frontend');
+    });
+  });
+
+  describe('getCanonicalTags', () => {
+    it('maps rows to CanonicalTag objects', () => {
+      (store.getCanonicalRows as ReturnType<typeof vi.fn>).mockReturnValue([
+        { tag: 'styling', description: 'CSS stuff', alias_count: 3 },
+      ]);
+      (store.countTagUsage as ReturnType<typeof vi.fn>).mockReturnValue(5);
+
+      const tags = getCanonicalTags(store);
+      expect(tags).toEqual([
+        { tag: 'styling', description: 'CSS stuff', usageCount: 5, aliasCount: 3 },
+      ]);
+    });
+
+    it('returns empty array when no canonicals', () => {
+      (store.getCanonicalRows as ReturnType<typeof vi.fn>).mockReturnValue([]);
+      expect(getCanonicalTags(store)).toEqual([]);
+    });
+  });
+
+  describe('seedDefaultAliases', () => {
+    it('inserts all unique canonical tags', () => {
+      seedDefaultAliases(store);
+      const uniqueCanonicals = new Set(DEFAULT_TAG_ALIASES.map(([, c]) => c));
+      expect(store.insertCanonical).toHaveBeenCalledTimes(uniqueCanonicals.size);
+    });
+
+    it('upserts all alias pairs', () => {
+      seedDefaultAliases(store);
+      expect(store.upsertAlias).toHaveBeenCalledTimes(DEFAULT_TAG_ALIASES.length);
+      // Spot check
+      expect(store.upsertAlias).toHaveBeenCalledWith('a11y', 'accessibility');
+      expect(store.upsertAlias).toHaveBeenCalledWith('ts', 'typescript');
+    });
+  });
+});

package/src/curator/tag-manager.ts

@@ -0,0 +1,109 @@
+/**
+ * Tag Manager — tag normalization, aliasing, and suggestion logic.
+ *
+ * Pure logic where possible; database access is delegated via a TagStore interface.
+ */
+
+import type { TagNormalizationResult, CanonicalTag } from './types.js';
+
+// ─── Constants ──────────────────────────────────────────────────────
+
+export const DEFAULT_TAG_ALIASES: Array<[string, string]> = [
+  ['a11y', 'accessibility'],
+  ['ts', 'typescript'],
+  ['js', 'javascript'],
+  ['css', 'styling'],
+  ['tailwind', 'styling'],
+  ['tw', 'styling'],
+  ['vitest', 'testing'],
+  ['jest', 'testing'],
+  ['perf', 'performance'],
+  ['sec', 'security'],
+  ['auth', 'authentication'],
+  ['i18n', 'internationalization'],
+  ['l10n', 'localization'],
+];
+
+// ─── Tag Store Interface ────────────────────────────────────────────
+
+/**
+ * Thin abstraction over the persistence layer for tag operations.
+ * Implemented by the Curator facade using its PersistenceProvider.
+ */
+export interface TagStore {
+  getAlias(lower: string): string | null;
+  insertCanonical(tag: string): void;
+  upsertAlias(alias: string, canonical: string): void;
+  getCanonicalRows(): Array<{ tag: string; description: string | null; alias_count: number }>;
+  countTagUsage(tag: string): number;
+}
+
+// ─── Normalize ──────────────────────────────────────────────────────
+
+export function normalizeTag(tag: string, store: TagStore): TagNormalizationResult {
+  const lower = tag.toLowerCase().trim();
+  const canonical = store.getAlias(lower);
+  if (canonical) {
+    return { original: tag, normalized: canonical, wasAliased: true };
+  }
+  return { original: tag, normalized: lower, wasAliased: false };
+}
+
+export function normalizeTags(tags: string[], store: TagStore): TagNormalizationResult[] {
+  return tags.map((tag) => normalizeTag(tag, store));
+}
+
+/**
+ * Deduplicate and return final tag list after normalization.
+ */
+export function normalizeAndDedup(
+  tags: string[],
+  store: TagStore,
+): { results: TagNormalizationResult[]; dedupedTags: string[]; changed: boolean } {
+  const results: TagNormalizationResult[] = [];
+  const normalizedTags: string[] = [];
+  let changed = false;
+
+  for (const tag of tags) {
+    const result = normalizeTag(tag, store);
+    results.push(result);
+    normalizedTags.push(result.normalized);
+    if (result.normalized !== tag) changed = true;
+  }
+
+  const dedupedTags = [...new Set(normalizedTags)];
+  return { results, dedupedTags, changed };
+}
+
+// ─── Alias Management ───────────────────────────────────────────────
+
+export function addTagAlias(alias: string, canonical: string, store: TagStore): void {
+  const lower = alias.toLowerCase().trim();
+  const canonicalLower = canonical.toLowerCase().trim();
+  store.insertCanonical(canonicalLower);
+  store.upsertAlias(lower, canonicalLower);
+}
+
+// ─── Canonical Tags ─────────────────────────────────────────────────
+
+export function getCanonicalTags(store: TagStore): CanonicalTag[] {
+  const rows = store.getCanonicalRows();
+  return rows.map((row) => ({
+    tag: row.tag,
+    description: row.description,
+    usageCount: store.countTagUsage(row.tag),
+    aliasCount: row.alias_count,
+  }));
+}
+
+// ─── Seed ───────────────────────────────────────────────────────────
+
+export function seedDefaultAliases(store: TagStore): void {
+  const canonicals = new Set(DEFAULT_TAG_ALIASES.map(([, c]) => c));
+  for (const tag of canonicals) {
+    store.insertCanonical(tag);
+  }
+  for (const [alias, canonical] of DEFAULT_TAG_ALIASES) {
+    store.upsertAlias(alias, canonical);
+  }
+}

package/src/domain-packs/inject-rules.test.ts

@@ -0,0 +1,117 @@
+/**
+ * Colocated tests for domain-packs/inject-rules.ts
+ *
+ * Tests: inject into new file, inject into existing, idempotent replace,
+ * remove, no-op on empty content.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { injectDomainRules, removeDomainRules } from './inject-rules.js';
+
+let tempDir: string;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), 'inject-rules-test-'));
+});
+
+afterEach(() => {
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe('injectDomainRules', () => {
+  it('creates file if it does not exist', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    injectDomainRules(filePath, 'design', '## Design Rules\nUse semantic tokens.');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).toContain('<!-- domain:design -->');
+    expect(content).toContain('## Design Rules');
+    expect(content).toContain('<!-- /domain:design -->');
+  });
+
+  it('appends to existing file', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, '# Agent Rules\n\nExisting content.\n');
+    injectDomainRules(filePath, 'security', 'Security rules here.');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).toContain('# Agent Rules');
+    expect(content).toContain('<!-- domain:security -->');
+    expect(content).toContain('Security rules here.');
+  });
+
+  it('is idempotent — replaces existing block', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, '# Header\n');
+    injectDomainRules(filePath, 'design', 'Version 1');
+    injectDomainRules(filePath, 'design', 'Version 2');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).not.toContain('Version 1');
+    expect(content).toContain('Version 2');
+    // Only one pair of markers
+    const openCount = content.split('<!-- domain:design -->').length - 1;
+    expect(openCount).toBe(1);
+  });
+
+  it('does nothing when content is empty', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, 'Original');
+    injectDomainRules(filePath, 'design', '');
+    expect(readFileSync(filePath, 'utf-8')).toBe('Original');
+  });
+
+  it('does nothing when content is whitespace-only', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, 'Original');
+    injectDomainRules(filePath, 'design', '   \n  \n  ');
+    expect(readFileSync(filePath, 'utf-8')).toBe('Original');
+  });
+
+  it('handles multiple pack injections independently', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, '# Agent\n');
+    injectDomainRules(filePath, 'design', 'Design rules');
+    injectDomainRules(filePath, 'security', 'Security rules');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).toContain('<!-- domain:design -->');
+    expect(content).toContain('<!-- domain:security -->');
+    expect(content).toContain('Design rules');
+    expect(content).toContain('Security rules');
+  });
+});
+
+describe('removeDomainRules', () => {
+  it('removes injected block', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, '# Header\n');
+    injectDomainRules(filePath, 'design', 'Rules to remove');
+    removeDomainRules(filePath, 'design');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).not.toContain('<!-- domain:design -->');
+    expect(content).not.toContain('Rules to remove');
+  });
+
+  it('does nothing if file does not exist', () => {
+    // Should not throw
+    removeDomainRules(join(tempDir, 'nonexistent.md'), 'design');
+  });
+
+  it('does nothing if markers are not found', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, '# Header\nNo markers here.\n');
+    removeDomainRules(filePath, 'design');
+    expect(readFileSync(filePath, 'utf-8')).toBe('# Header\nNo markers here.\n');
+  });
+
+  it('only removes the targeted pack block', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, '# Header\n');
+    injectDomainRules(filePath, 'design', 'Design rules');
+    injectDomainRules(filePath, 'security', 'Security rules');
+    removeDomainRules(filePath, 'design');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).not.toContain('Design rules');
+    expect(content).toContain('Security rules');
+  });
+});