@soleri/core 9.0.3 → 9.2.0

package/src/__tests__/identity-manager.test.ts

@@ -1,243 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { createAgentRuntime } from '../runtime/runtime.js';
-import { IdentityManager } from '../control/identity-manager.js';
-import type { AgentRuntime } from '../runtime/types.js';
-
-describe('IdentityManager', () => {
-  let runtime: AgentRuntime;
-  let manager: IdentityManager;
-  let plannerDir: string;
-  const AGENT = 'test-agent';
-
-  beforeEach(() => {
-    plannerDir = join(tmpdir(), 'identity-test-' + Date.now());
-    mkdirSync(plannerDir, { recursive: true });
-    runtime = createAgentRuntime({
-      agentId: 'identity-test',
-      vaultPath: ':memory:',
-      plansPath: join(plannerDir, 'plans.json'),
-    });
-    manager = new IdentityManager(runtime.vault);
-  });
-
-  afterEach(() => {
-    runtime.close();
-    rmSync(plannerDir, { recursive: true, force: true });
-  });
-
-  // ─── Identity CRUD ──────────────────────────────────────────────────
-
-  it('should return null for unknown agent', () => {
-    expect(manager.getIdentity('nonexistent')).toBeNull();
-  });
-
-  it('should create identity with defaults', () => {
-    const identity = manager.setIdentity(AGENT, { name: 'TestBot' });
-    expect(identity.agentId).toBe(AGENT);
-    expect(identity.name).toBe('TestBot');
-    expect(identity.role).toBe('');
-    expect(identity.description).toBe('');
-    expect(identity.personality).toEqual([]);
-    expect(identity.version).toBe(1);
-    expect(identity.guidelines).toEqual([]);
-  });
-
-  it('should create identity with all fields', () => {
-    const identity = manager.setIdentity(AGENT, {
-      name: 'TestBot',
-      role: 'Test Runner',
-      description: 'A test agent',
-      personality: ['precise', 'thorough'],
-    });
-    expect(identity.name).toBe('TestBot');
-    expect(identity.role).toBe('Test Runner');
-    expect(identity.description).toBe('A test agent');
-    expect(identity.personality).toEqual(['precise', 'thorough']);
-  });
-
-  it('should use agentId as name if name not provided', () => {
-    const identity = manager.setIdentity(AGENT, {});
-    expect(identity.name).toBe(AGENT);
-  });
-
-  it('should retrieve identity after creation', () => {
-    manager.setIdentity(AGENT, { name: 'TestBot', role: 'Runner' });
-    const identity = manager.getIdentity(AGENT);
-    expect(identity).not.toBeNull();
-    expect(identity!.name).toBe('TestBot');
-    expect(identity!.role).toBe('Runner');
-  });
-
-  it('should update identity with partial fields', () => {
-    manager.setIdentity(AGENT, { name: 'V1', role: 'Role1', description: 'Desc1' });
-    const updated = manager.setIdentity(AGENT, { role: 'Role2' });
-    expect(updated.name).toBe('V1');
-    expect(updated.role).toBe('Role2');
-    expect(updated.description).toBe('Desc1');
-    expect(updated.version).toBe(2);
-  });
-
-  it('should increment version on each update', () => {
-    manager.setIdentity(AGENT, { name: 'V1' });
-    manager.setIdentity(AGENT, { name: 'V2' });
-    manager.setIdentity(AGENT, { name: 'V3' });
-    const identity = manager.getIdentity(AGENT);
-    expect(identity!.version).toBe(3);
-  });
-
-  // ─── Guidelines ─────────────────────────────────────────────────────
-
-  it('should add a guideline', () => {
-    const guideline = manager.addGuideline(AGENT, {
-      category: 'behavior',
-      text: 'Always be helpful',
-    });
-    expect(guideline.id).toBeDefined();
-    expect(guideline.category).toBe('behavior');
-    expect(guideline.text).toBe('Always be helpful');
-    expect(guideline.priority).toBe(0);
-  });
-
-  it('should add guideline with priority', () => {
-    const guideline = manager.addGuideline(AGENT, {
-      category: 'restriction',
-      text: 'Never share secrets',
-      priority: 10,
-    });
-    expect(guideline.priority).toBe(10);
-  });
-
-  it('should list guidelines by category', () => {
-    manager.addGuideline(AGENT, { category: 'behavior', text: 'Be helpful' });
-    manager.addGuideline(AGENT, { category: 'restriction', text: 'No secrets' });
-    manager.addGuideline(AGENT, { category: 'behavior', text: 'Be concise' });
-
-    const behaviors = manager.getGuidelines(AGENT, 'behavior');
-    expect(behaviors).toHaveLength(2);
-    expect(behaviors.every((g) => g.category === 'behavior')).toBe(true);
-
-    const restrictions = manager.getGuidelines(AGENT, 'restriction');
-    expect(restrictions).toHaveLength(1);
-  });
-
-  it('should list all guidelines', () => {
-    manager.addGuideline(AGENT, { category: 'behavior', text: 'A' });
-    manager.addGuideline(AGENT, { category: 'style', text: 'B' });
-    const all = manager.getGuidelines(AGENT);
-    expect(all).toHaveLength(2);
-  });
-
-  it('should remove a guideline', () => {
-    const guideline = manager.addGuideline(AGENT, { category: 'behavior', text: 'Temp' });
-    expect(manager.removeGuideline(guideline.id)).toBe(true);
-    expect(manager.getGuidelines(AGENT)).toHaveLength(0);
-  });
-
-  it('should return false removing nonexistent guideline', () => {
-    expect(manager.removeGuideline('nonexistent-id')).toBe(false);
-  });
-
-  it('should include guidelines in getIdentity', () => {
-    manager.setIdentity(AGENT, { name: 'Bot' });
-    manager.addGuideline(AGENT, { category: 'behavior', text: 'Be helpful' });
-    manager.addGuideline(AGENT, { category: 'restriction', text: 'No secrets' });
-
-    const identity = manager.getIdentity(AGENT);
-    expect(identity!.guidelines).toHaveLength(2);
-  });
-
-  it('should order guidelines by priority descending', () => {
-    manager.addGuideline(AGENT, { category: 'behavior', text: 'Low', priority: 1 });
-    manager.addGuideline(AGENT, { category: 'behavior', text: 'High', priority: 10 });
-    manager.addGuideline(AGENT, { category: 'behavior', text: 'Mid', priority: 5 });
-
-    const guidelines = manager.getGuidelines(AGENT, 'behavior');
-    expect(guidelines[0].text).toBe('High');
-    expect(guidelines[1].text).toBe('Mid');
-    expect(guidelines[2].text).toBe('Low');
-  });
-
-  // ─── Versioning ─────────────────────────────────────────────────────
-
-  it('should track version history', () => {
-    manager.setIdentity(AGENT, { name: 'V1', changedBy: 'user', changeReason: 'Initial' });
-    manager.setIdentity(AGENT, { name: 'V2', changedBy: 'user', changeReason: 'Update' });
-
-    const history = manager.getVersionHistory(AGENT);
-    expect(history).toHaveLength(1);
-    expect(history[0].version).toBe(1);
-    expect(history[0].changedBy).toBe('user');
-    expect(history[0].changeReason).toBe('Update');
-  });
-
-  it('should rollback to a previous version', () => {
-    manager.setIdentity(AGENT, { name: 'Original', role: 'V1 Role' });
-    manager.setIdentity(AGENT, { name: 'Updated', role: 'V2 Role' });
-
-    const current = manager.getIdentity(AGENT);
-    expect(current!.name).toBe('Updated');
-    expect(current!.version).toBe(2);
-
-    const rolledBack = manager.rollback(AGENT, 1);
-    expect(rolledBack.name).toBe('Original');
-    expect(rolledBack.role).toBe('V1 Role');
-    expect(rolledBack.version).toBe(3);
-  });
-
-  it('should throw on rollback to nonexistent version', () => {
-    manager.setIdentity(AGENT, { name: 'V1' });
-    expect(() => manager.rollback(AGENT, 99)).toThrow('Version 99 not found');
-  });
-
-  it('should preserve version history after rollback', () => {
-    manager.setIdentity(AGENT, { name: 'V1' });
-    manager.setIdentity(AGENT, { name: 'V2' });
-    manager.rollback(AGENT, 1);
-
-    const history = manager.getVersionHistory(AGENT);
-    expect(history).toHaveLength(2);
-    expect(history[0].version).toBe(2);
-    expect(history[1].version).toBe(1);
-  });
-
-  it('should limit version history', () => {
-    manager.setIdentity(AGENT, { name: 'V1' });
-    manager.setIdentity(AGENT, { name: 'V2' });
-    manager.setIdentity(AGENT, { name: 'V3' });
-    manager.setIdentity(AGENT, { name: 'V4' });
-
-    const limited = manager.getVersionHistory(AGENT, 2);
-    expect(limited).toHaveLength(2);
-    expect(limited[0].version).toBe(3);
-    expect(limited[1].version).toBe(2);
-  });
-
-  // ─── Rendering ──────────────────────────────────────────────────────
-
-  it('should render unknown agent markdown', () => {
-    const md = manager.renderIdentityMarkdown('unknown');
-    expect(md).toContain('Unknown Agent');
-  });
-
-  it('should render identity as markdown', () => {
-    manager.setIdentity(AGENT, {
-      name: 'TestBot',
-      role: 'Runner',
-      description: 'A helpful agent.',
-      personality: ['precise', 'kind'],
-    });
-    manager.addGuideline(AGENT, { category: 'behavior', text: 'Be helpful' });
-    manager.addGuideline(AGENT, { category: 'restriction', text: 'No secrets' });
-
-    const md = manager.renderIdentityMarkdown(AGENT);
-    expect(md).toContain('# TestBot');
-    expect(md).toContain('**Role:** Runner');
-    expect(md).toContain('A helpful agent.');
-    expect(md).toContain('- precise');
-    expect(md).toContain('- Be helpful');
-    expect(md).toContain('- No secrets');
-  });
-});

package/src/__tests__/intake-pipeline.test.ts

@@ -1,162 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { dedupItems, DEDUP_THRESHOLD } from '../intake/dedup-gate.js';
-import { Vault } from '../vault/vault.js';
-import type { ClassifiedItem } from '../intake/types.js';
-
-function makeItem(overrides: Partial<ClassifiedItem> = {}): ClassifiedItem {
-  return {
-    type: overrides.type ?? 'pattern',
-    title: overrides.title ?? 'Test Pattern',
-    description: overrides.description ?? 'A generic test description.',
-    tags: overrides.tags ?? ['test'],
-    severity: overrides.severity ?? 'suggestion',
-    citation: overrides.citation ?? 'p.1',
-  };
-}
-
-describe('Dedup Gate', () => {
-  let vault: Vault;
-
-  beforeEach(() => {
-    vault = new Vault(':memory:');
-  });
-
-  afterEach(() => {
-    vault.close();
-  });
-
-  it('should mark items as non-duplicate when vault is empty', () => {
-    const items: ClassifiedItem[] = [
-      makeItem({ title: 'Brand New Pattern', description: 'Something entirely new.' }),
-    ];
-
-    const results = dedupItems(items, vault);
-
-    expect(results).toHaveLength(1);
-    expect(results[0].isDuplicate).toBe(false);
-    expect(results[0].similarity).toBe(0);
-    expect(results[0].bestMatchId).toBeUndefined();
-    expect(results[0].item).toBe(items[0]);
-  });
-
-  it('should detect near-duplicates with high similarity', () => {
-    vault.seed([
-      {
-        id: 'existing-1',
-        type: 'pattern',
-        domain: 'design-patterns',
-        title: 'Singleton Pattern Implementation',
-        severity: 'suggestion',
-        description:
-          'The singleton pattern ensures a class has only one instance and provides a global point of access to it.',
-        tags: ['singleton', 'design-pattern', 'creational'],
-      },
-    ]);
-
-    const items: ClassifiedItem[] = [
-      makeItem({
-        title: 'Singleton Pattern Implementation',
-        description:
-          'The singleton pattern ensures a class has only one instance and provides a global point of access to it.',
-        tags: ['singleton', 'design-pattern', 'creational'],
-      }),
-    ];
-
-    const results = dedupItems(items, vault);
-
-    expect(results).toHaveLength(1);
-    expect(results[0].similarity).toBeGreaterThan(0.5);
-    expect(results[0].bestMatchId).toBe('existing-1');
-  });
-
-  it('should not flag dissimilar entries as duplicates', () => {
-    vault.seed([
-      {
-        id: 'existing-2',
-        type: 'pattern',
-        domain: 'design-patterns',
-        title: 'Observer Pattern',
-        severity: 'suggestion',
-        description:
-          'The observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified.',
-        tags: ['observer', 'design-pattern', 'behavioral'],
-      },
-    ]);
-
-    const items: ClassifiedItem[] = [
-      makeItem({
-        title: 'God Object Anti-Pattern',
-        description:
-          'A god object is an anti-pattern where a single class knows too much or does too much, violating the single responsibility principle.',
-        tags: ['anti-pattern', 'code-smell'],
-      }),
-    ];
-
-    const results = dedupItems(items, vault);
-
-    expect(results).toHaveLength(1);
-    expect(results[0].isDuplicate).toBe(false);
-  });
-
-  it('should handle multiple items at once', () => {
-    vault.seed([
-      {
-        id: 'existing-3',
-        type: 'pattern',
-        domain: 'design-patterns',
-        title: 'Factory Method Pattern',
-        severity: 'suggestion',
-        description:
-          'The factory method pattern defines an interface for creating an object but lets subclasses decide which class to instantiate.',
-        tags: ['factory', 'design-pattern', 'creational'],
-      },
-    ]);
-
-    const items: ClassifiedItem[] = [
-      // Near-duplicate of vault entry
-      makeItem({
-        title: 'Factory Method Pattern',
-        description:
-          'The factory method pattern defines an interface for creating an object but lets subclasses decide which class to instantiate.',
-        tags: ['factory', 'design-pattern', 'creational'],
-      }),
-      // Completely different
-      makeItem({
-        title: 'Dependency Injection',
-        description:
-          'Dependency injection is a technique where an object receives other objects that it depends on, called dependencies, rather than creating them internally.',
-        tags: ['dependency-injection', 'inversion-of-control'],
-      }),
-      // Also different
-      makeItem({
-        title: 'Circuit Breaker Pattern',
-        description:
-          'The circuit breaker pattern prevents an application from repeatedly trying to execute an operation that is likely to fail, allowing it to recover gracefully.',
-        tags: ['resilience', 'distributed-systems'],
-      }),
-    ];
-
-    const results = dedupItems(items, vault);
-
-    expect(results).toHaveLength(3);
-
-    // First item is a near-duplicate — should have high similarity
-    expect(results[0].similarity).toBeGreaterThan(0.5);
-    expect(results[0].bestMatchId).toBe('existing-3');
-
-    // Second and third items are different — should not be duplicates
-    expect(results[1].isDuplicate).toBe(false);
-    expect(results[2].isDuplicate).toBe(false);
-  });
-
-  it('DEDUP_THRESHOLD should be 0.85', () => {
-    expect(DEDUP_THRESHOLD).toBe(0.85);
-  });
-});
-
-describe('Intake Types', () => {
-  it('should import all type definitions', async () => {
-    const types = await import('../intake/types.js');
-    expect(types).toBeDefined();
-  });
-});

package/src/__tests__/intent-router.test.ts

@@ -1,222 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { createAgentRuntime } from '../runtime/runtime.js';
-import { IntentRouter } from '../control/intent-router.js';
-import type { AgentRuntime } from '../runtime/types.js';
-import type { OperationalMode } from '../control/types.js';
-
-describe('IntentRouter', () => {
-  let runtime: AgentRuntime;
-  let router: IntentRouter;
-  let plannerDir: string;
-
-  beforeEach(() => {
-    plannerDir = join(tmpdir(), 'intent-test-' + Date.now());
-    mkdirSync(plannerDir, { recursive: true });
-    runtime = createAgentRuntime({
-      agentId: 'intent-test',
-      vaultPath: ':memory:',
-      plansPath: join(plannerDir, 'plans.json'),
-    });
-    router = new IntentRouter(runtime.vault);
-  });
-
-  afterEach(() => {
-    runtime.close();
-    rmSync(plannerDir, { recursive: true, force: true });
-  });
-
-  // ─── Default Modes ──────────────────────────────────────────────────
-
-  it('should seed 10 default modes', () => {
-    const modes = router.getModes();
-    expect(modes).toHaveLength(10);
-  });
-
-  it('should include all expected modes', () => {
-    const modeNames = router.getModes().map((m) => m.mode);
-    expect(modeNames).toContain('BUILD-MODE');
-    expect(modeNames).toContain('FIX-MODE');
-    expect(modeNames).toContain('VALIDATE-MODE');
-    expect(modeNames).toContain('DESIGN-MODE');
-    expect(modeNames).toContain('IMPROVE-MODE');
-    expect(modeNames).toContain('DELIVER-MODE');
-    expect(modeNames).toContain('EXPLORE-MODE');
-    expect(modeNames).toContain('PLAN-MODE');
-    expect(modeNames).toContain('REVIEW-MODE');
-    expect(modeNames).toContain('GENERAL-MODE');
-  });
-
-  it('should start in GENERAL-MODE', () => {
-    expect(router.getCurrentMode()).toBe('GENERAL-MODE');
-  });
-
-  // ─── Intent Classification ──────────────────────────────────────────
-
-  it('should route "fix this bug" to FIX-MODE', () => {
-    const result = router.routeIntent('fix this bug');
-    expect(result.intent).toBe('fix');
-    expect(result.mode).toBe('FIX-MODE');
-    expect(result.confidence).toBeGreaterThan(0);
-    expect(result.method).toBe('keyword');
-    expect(result.matchedKeywords).toContain('fix');
-    expect(result.matchedKeywords).toContain('bug');
-  });
-
-  it('should route "build a new feature" to BUILD-MODE', () => {
-    const result = router.routeIntent('build a new feature');
-    expect(result.intent).toBe('build');
-    expect(result.mode).toBe('BUILD-MODE');
-    expect(result.matchedKeywords).toContain('build');
-    expect(result.matchedKeywords).toContain('new');
-    expect(result.matchedKeywords).toContain('feature');
-  });
-
-  it('should route "refactor the auth module" to IMPROVE-MODE', () => {
-    const result = router.routeIntent('refactor the auth module');
-    expect(result.intent).toBe('improve');
-    expect(result.mode).toBe('IMPROVE-MODE');
-  });
-
-  it('should route "deploy to production" to DELIVER-MODE', () => {
-    const result = router.routeIntent('deploy to production');
-    expect(result.intent).toBe('deliver');
-    expect(result.mode).toBe('DELIVER-MODE');
-  });
-
-  it('should route "review this code" to REVIEW-MODE', () => {
-    const result = router.routeIntent('review this code');
-    expect(result.intent).toBe('review');
-    expect(result.mode).toBe('REVIEW-MODE');
-  });
-
-  it('should route "plan the architect strategy" to PLAN-MODE', () => {
-    const result = router.routeIntent('plan the architect strategy');
-    expect(result.intent).toBe('plan');
-    expect(result.mode).toBe('PLAN-MODE');
-    expect(result.matchedKeywords).toContain('plan');
-    expect(result.matchedKeywords).toContain('architect');
-    expect(result.matchedKeywords).toContain('strategy');
-  });
-
-  it('should fall back to GENERAL-MODE for unrecognized input', () => {
-    const result = router.routeIntent('hello there how are you');
-    expect(result.intent).toBe('general');
-    expect(result.mode).toBe('GENERAL-MODE');
-    expect(result.confidence).toBe(0);
-    expect(result.matchedKeywords).toEqual([]);
-  });
-
-  it('should update current mode after routing', () => {
-    router.routeIntent('fix this bug');
-    expect(router.getCurrentMode()).toBe('FIX-MODE');
-  });
-
-  it('should handle case-insensitive matching', () => {
-    const result = router.routeIntent('FIX this BUG');
-    expect(result.intent).toBe('fix');
-    expect(result.mode).toBe('FIX-MODE');
-  });
-
-  it('should cap confidence at 1.0', () => {
-    const result = router.routeIntent('fix bug broken error crash issue debug repair janky');
-    expect(result.confidence).toBeLessThanOrEqual(1.0);
-  });
-
-  // ─── Mode Management ───────────────────────────────────────────────
-
-  it('should morph to a specified mode', () => {
-    const result = router.morph('BUILD-MODE');
-    expect(result.previousMode).toBe('GENERAL-MODE');
-    expect(result.currentMode).toBe('BUILD-MODE');
-    expect(result.behaviorRules.length).toBeGreaterThan(0);
-    expect(router.getCurrentMode()).toBe('BUILD-MODE');
-  });
-
-  it('should throw on morph to unknown mode', () => {
-    expect(() => router.morph('UNKNOWN-MODE' as OperationalMode)).toThrow('Unknown mode');
-  });
-
-  it('should get behavior rules for current mode', () => {
-    router.morph('FIX-MODE');
-    const rules = router.getBehaviorRules();
-    expect(rules).toContain('Identify root cause first');
-  });
-
-  it('should get behavior rules for a specific mode', () => {
-    const rules = router.getBehaviorRules('DESIGN-MODE');
-    expect(rules).toContain('Use semantic tokens');
-  });
-
-  it('should return empty rules for unknown mode', () => {
-    const rules = router.getBehaviorRules('NONEXISTENT' as OperationalMode);
-    expect(rules).toEqual([]);
-  });
-
-  // ─── Custom Modes ──────────────────────────────────────────────────
-
-  it('should register a custom mode', () => {
-    router.registerMode({
-      mode: 'CUSTOM-MODE' as OperationalMode,
-      intent: 'general' as const,
-      description: 'Custom test mode',
-      behaviorRules: ['Custom rule'],
-      keywords: ['custom', 'special'],
-    });
-    const modes = router.getModes();
-    expect(modes.length).toBe(11);
-    const custom = modes.find((m) => m.mode === 'CUSTOM-MODE');
-    expect(custom).toBeDefined();
-    expect(custom!.keywords).toContain('custom');
-  });
-
-  it('should route to custom mode', () => {
-    router.registerMode({
-      mode: 'CUSTOM-MODE' as OperationalMode,
-      intent: 'general' as const,
-      description: 'Custom test mode',
-      behaviorRules: ['Custom rule'],
-      keywords: ['custom', 'special'],
-    });
-    const result = router.routeIntent('do something custom and special');
-    expect(result.mode).toBe('CUSTOM-MODE');
-  });
-
-  it('should update mode rules', () => {
-    router.updateModeRules('BUILD-MODE', ['New rule 1', 'New rule 2']);
-    const rules = router.getBehaviorRules('BUILD-MODE');
-    expect(rules).toEqual(['New rule 1', 'New rule 2']);
-  });
-
-  it('should throw on updating unknown mode rules', () => {
-    expect(() => router.updateModeRules('NONEXISTENT' as OperationalMode, ['Rule'])).toThrow(
-      'Unknown mode',
-    );
-  });
-
-  // ─── Analytics ──────────────────────────────────────────────────────
-
-  it('should track routing stats', () => {
-    router.routeIntent('fix this bug');
-    router.routeIntent('build a feature');
-    router.routeIntent('fix another error');
-    router.routeIntent('hello there');
-
-    const stats = router.getRoutingStats();
-    expect(stats.totalRouted).toBe(4);
-    expect(stats.byIntent.fix).toBe(2);
-    expect(stats.byIntent.build).toBe(1);
-    expect(stats.byIntent.general).toBe(1);
-    expect(stats.byMode['FIX-MODE']).toBe(2);
-    expect(stats.byMode['BUILD-MODE']).toBe(1);
-  });
-
-  it('should return empty stats initially', () => {
-    const stats = router.getRoutingStats();
-    expect(stats.totalRouted).toBe(0);
-    expect(stats.byIntent).toEqual({});
-    expect(stats.byMode).toEqual({});
-  });
-});