@dot-ai/core 0.5.2

package/src/__tests__/engine.test.ts

@@ -0,0 +1,305 @@
+import { describe, it, expect, vi } from 'vitest';
+import { boot, enrich, learn } from '../engine.js';
+import type { Providers } from '../engine.js';
+
+function createMockProviders(overrides?: Partial<Providers>): Providers {
+  return {
+    memory: {
+      search: vi.fn().mockResolvedValue([]),
+      store: vi.fn().mockResolvedValue(undefined),
+    },
+    skills: {
+      list: vi.fn().mockResolvedValue([]),
+      match: vi.fn().mockResolvedValue([]),
+      load: vi.fn().mockResolvedValue(null),
+    },
+    identity: {
+      load: vi.fn().mockResolvedValue([]),
+    },
+    routing: {
+      route: vi.fn().mockResolvedValue({ model: 'sonnet', reason: 'default' }),
+    },
+    tasks: {
+      list: vi.fn().mockResolvedValue([]),
+      get: vi.fn().mockResolvedValue(null),
+      create: vi.fn(),
+      update: vi.fn(),
+    },
+    tools: {
+      list: vi.fn().mockResolvedValue([]),
+      match: vi.fn().mockResolvedValue([]),
+      load: vi.fn().mockResolvedValue(null),
+    },
+    ...overrides,
+  };
+}
+
+describe('boot', () => {
+  it('calls identity.load(), skills.list(), tools.list()', async () => {
+    const providers = createMockProviders();
+    await boot(providers);
+    expect(providers.identity.load).toHaveBeenCalledOnce();
+    expect(providers.skills.list).toHaveBeenCalledOnce();
+    expect(providers.tools.list).toHaveBeenCalledOnce();
+  });
+
+  it('returns a BootCache with identities, vocabulary, skills', async () => {
+    const providers = createMockProviders();
+    const cache = await boot(providers);
+    expect(cache).toHaveProperty('identities');
+    expect(cache).toHaveProperty('vocabulary');
+    expect(cache).toHaveProperty('skills');
+  });
+
+  it('populates identities from identity provider', async () => {
+    const mockIdentities = [
+      { type: 'agents', content: 'I am Kiwi', source: 'file', priority: 1 },
+    ];
+    const providers = createMockProviders({
+      identity: { load: vi.fn().mockResolvedValue(mockIdentities) },
+    });
+    const cache = await boot(providers);
+    expect(cache.identities).toEqual(mockIdentities);
+  });
+
+  it('populates skills from skills provider', async () => {
+    const mockSkills = [
+      { name: 'dot-ai-tasks', description: 'Task management', labels: ['tasks', 'cockpit'] },
+    ];
+    const providers = createMockProviders({
+      skills: {
+        list: vi.fn().mockResolvedValue(mockSkills),
+        match: vi.fn().mockResolvedValue([]),
+        load: vi.fn().mockResolvedValue(null),
+      },
+    });
+    const cache = await boot(providers);
+    expect(cache.skills).toEqual(mockSkills);
+  });
+
+  it('builds vocabulary from skill and tool labels', async () => {
+    const providers = createMockProviders({
+      skills: {
+        list: vi.fn().mockResolvedValue([
+          { name: 'skill-a', description: 'A', labels: ['memory', 'routing'] },
+        ]),
+        match: vi.fn().mockResolvedValue([]),
+        load: vi.fn().mockResolvedValue(null),
+      },
+      tools: {
+        list: vi.fn().mockResolvedValue([
+          { name: 'tool-b', description: 'B', labels: ['ui', 'ux'], config: {}, source: 'file' },
+        ]),
+        match: vi.fn().mockResolvedValue([]),
+        load: vi.fn().mockResolvedValue(null),
+      },
+    });
+    const cache = await boot(providers);
+    expect(cache.vocabulary).toContain('memory');
+    expect(cache.vocabulary).toContain('routing');
+    expect(cache.vocabulary).toContain('ui');
+    expect(cache.vocabulary).toContain('ux');
+  });
+
+  it('calls identity, skills, and tools providers in parallel (all called before any awaited)', async () => {
+    const callOrder: string[] = [];
+    const providers = createMockProviders({
+      identity: {
+        load: vi.fn().mockImplementation(async () => {
+          callOrder.push('identity');
+          return [];
+        }),
+      },
+      skills: {
+        list: vi.fn().mockImplementation(async () => {
+          callOrder.push('skills');
+          return [];
+        }),
+        match: vi.fn().mockResolvedValue([]),
+        load: vi.fn().mockResolvedValue(null),
+      },
+      tools: {
+        list: vi.fn().mockImplementation(async () => {
+          callOrder.push('tools');
+          return [];
+        }),
+        match: vi.fn().mockResolvedValue([]),
+        load: vi.fn().mockResolvedValue(null),
+      },
+    });
+    await boot(providers);
+    // All three should have been called (order may vary in parallel)
+    expect(callOrder).toContain('identity');
+    expect(callOrder).toContain('skills');
+    expect(callOrder).toContain('tools');
+  });
+});
+
+describe('enrich', () => {
+  const baseCache = {
+    identities: [{ type: 'agents', content: 'I am Kiwi', source: 'file', priority: 1 }],
+    vocabulary: ['memory', 'routing', 'tasks'],
+    skills: [],
+  };
+
+  it('returns an EnrichedContext with all required fields', async () => {
+    const providers = createMockProviders();
+    const result = await enrich('fix the memory issue', providers, baseCache);
+    expect(result).toHaveProperty('prompt');
+    expect(result).toHaveProperty('labels');
+    expect(result).toHaveProperty('identities');
+    expect(result).toHaveProperty('memories');
+    expect(result).toHaveProperty('skills');
+    expect(result).toHaveProperty('tools');
+    expect(result).toHaveProperty('routing');
+  });
+
+  it('includes the original prompt in the result', async () => {
+    const providers = createMockProviders();
+    const result = await enrich('fix the memory issue', providers, baseCache);
+    expect(result.prompt).toBe('fix the memory issue');
+  });
+
+  it('extracts labels from prompt against vocabulary', async () => {
+    const providers = createMockProviders();
+    const result = await enrich('fix the memory issue', providers, baseCache);
+    const labelNames = result.labels.map((l) => l.name);
+    expect(labelNames).toContain('memory');
+    expect(labelNames).not.toContain('routing');
+  });
+
+  it('includes identities from cache', async () => {
+    const providers = createMockProviders();
+    const result = await enrich('hello', providers, baseCache);
+    expect(result.identities).toEqual(baseCache.identities);
+  });
+
+  it('calls memory.search with prompt and extracted label names', async () => {
+    const providers = createMockProviders();
+    await enrich('fix the memory issue', providers, baseCache);
+    expect(providers.memory.search).toHaveBeenCalledWith('fix the memory issue', ['memory']);
+  });
+
+  it('calls skills.match with extracted labels', async () => {
+    const providers = createMockProviders();
+    await enrich('fix the routing logic', providers, baseCache);
+    expect(providers.skills.match).toHaveBeenCalledWith(
+      expect.arrayContaining([expect.objectContaining({ name: 'routing' })]),
+    );
+  });
+
+  it('calls tools.match with extracted labels', async () => {
+    const providers = createMockProviders();
+    await enrich('tasks need fixing', providers, baseCache);
+    expect(providers.tools.match).toHaveBeenCalledWith(
+      expect.arrayContaining([expect.objectContaining({ name: 'tasks' })]),
+    );
+  });
+
+  it('calls routing.route with extracted labels', async () => {
+    const providers = createMockProviders();
+    await enrich('fix the memory issue', providers, baseCache);
+    expect(providers.routing.route).toHaveBeenCalledWith(
+      expect.arrayContaining([expect.objectContaining({ name: 'memory' })]),
+    );
+  });
+
+  it('populates memories from memory.search result', async () => {
+    const mockMemories = [
+      { content: 'Memory fact', type: 'fact', source: 'file' },
+    ];
+    const providers = createMockProviders({
+      memory: {
+        search: vi.fn().mockResolvedValue(mockMemories),
+        store: vi.fn().mockResolvedValue(undefined),
+      },
+    });
+    const result = await enrich('fix the memory issue', providers, baseCache);
+    expect(result.memories).toEqual(mockMemories);
+  });
+
+  it('populates skills from skills.match result', async () => {
+    const mockSkills = [
+      { name: 'dot-ai-tasks', description: 'Tasks', labels: ['tasks'] },
+    ];
+    const providers = createMockProviders({
+      skills: {
+        list: vi.fn().mockResolvedValue([]),
+        match: vi.fn().mockResolvedValue(mockSkills),
+        load: vi.fn().mockResolvedValue(null),
+      },
+    });
+    const result = await enrich('hello', providers, baseCache);
+    expect(result.skills).toEqual(mockSkills);
+  });
+
+  it('populates routing from routing.route result', async () => {
+    const mockRouting = { model: 'opus', reason: 'complex task' };
+    const providers = createMockProviders({
+      routing: { route: vi.fn().mockResolvedValue(mockRouting) },
+    });
+    const result = await enrich('hello', providers, baseCache);
+    expect(result.routing).toEqual(mockRouting);
+  });
+
+  it('calls memory, skills, tools, routing in parallel', async () => {
+    const callOrder: string[] = [];
+    const providers = createMockProviders({
+      memory: {
+        search: vi.fn().mockImplementation(async () => { callOrder.push('memory'); return []; }),
+        store: vi.fn().mockResolvedValue(undefined),
+      },
+      skills: {
+        list: vi.fn().mockResolvedValue([]),
+        match: vi.fn().mockImplementation(async () => { callOrder.push('skills'); return []; }),
+        load: vi.fn().mockResolvedValue(null),
+      },
+      tools: {
+        list: vi.fn().mockResolvedValue([]),
+        match: vi.fn().mockImplementation(async () => { callOrder.push('tools'); return []; }),
+        load: vi.fn().mockResolvedValue(null),
+      },
+      routing: {
+        route: vi.fn().mockImplementation(async () => { callOrder.push('routing'); return { model: 'sonnet', reason: 'default' }; }),
+      },
+    });
+    await enrich('hello world', providers, baseCache);
+    expect(callOrder).toContain('memory');
+    expect(callOrder).toContain('skills');
+    expect(callOrder).toContain('tools');
+    expect(callOrder).toContain('routing');
+  });
+});
+
+describe('learn', () => {
+  it('calls memory.store with the response', async () => {
+    const providers = createMockProviders();
+    await learn('This is what I learned today', providers);
+    expect(providers.memory.store).toHaveBeenCalledOnce();
+    expect(providers.memory.store).toHaveBeenCalledWith(
+      expect.objectContaining({ content: 'This is what I learned today', type: 'log' }),
+    );
+  });
+
+  it('stores entry with today\'s date', async () => {
+    const providers = createMockProviders();
+    const today = new Date().toISOString().slice(0, 10);
+    await learn('response', providers);
+    expect(providers.memory.store).toHaveBeenCalledWith(
+      expect.objectContaining({ date: today }),
+    );
+  });
+
+  it('does not call any other provider methods', async () => {
+    const providers = createMockProviders();
+    await learn('response', providers);
+    expect(providers.skills.list).not.toHaveBeenCalled();
+    expect(providers.identity.load).not.toHaveBeenCalled();
+    expect(providers.routing.route).not.toHaveBeenCalled();
+  });
+
+  it('resolves without error on successful store', async () => {
+    const providers = createMockProviders();
+    await expect(learn('response', providers)).resolves.toBeUndefined();
+  });
+});

package/src/__tests__/format.test.ts

@@ -0,0 +1,247 @@
+import { describe, it, expect } from 'vitest';
+import { formatContext } from '../format.js';
+import type { EnrichedContext, Identity, MemoryEntry, Skill, Tool } from '../types.js';
+
+function makeContext(overrides?: Partial<EnrichedContext>): EnrichedContext {
+  return {
+    prompt: 'test prompt',
+    labels: [],
+    identities: [],
+    memories: [],
+    skills: [],
+    tools: [],
+    routing: { model: 'default', reason: '' },
+    ...overrides,
+  };
+}
+
+function makeIdentity(overrides?: Partial<Identity>): Identity {
+  return {
+    type: 'agents',
+    content: 'You are Kiwi.',
+    source: 'file',
+    priority: 10,
+    ...overrides,
+  };
+}
+
+function makeMemory(overrides?: Partial<MemoryEntry>): MemoryEntry {
+  return {
+    content: 'User prefers TypeScript',
+    type: 'fact',
+    source: 'file',
+    ...overrides,
+  };
+}
+
+function makeSkill(overrides?: Partial<Skill>): Skill {
+  return {
+    name: 'my-skill',
+    description: 'A skill',
+    labels: [],
+    content: 'Skill content here.',
+    ...overrides,
+  };
+}
+
+function makeTool(overrides?: Partial<Tool>): Tool {
+  return {
+    name: 'bash',
+    description: 'Run shell commands',
+    labels: [],
+    config: {},
+    source: 'file',
+    ...overrides,
+  };
+}
+
+describe('formatContext', () => {
+  it('includes all sections when identities, memories, skills, and tools are present', () => {
+    const ctx = makeContext({
+      identities: [makeIdentity({ content: 'You are Kiwi.' })],
+      memories: [makeMemory({ content: 'User prefers TypeScript' })],
+      skills: [makeSkill({ name: 'dot-ai', content: 'dot-ai skill content' })],
+      tools: [makeTool({ name: 'bash', description: 'Run shell commands' })],
+    });
+
+    const result = formatContext(ctx);
+
+    expect(result).toContain('You are Kiwi.');
+    expect(result).toContain('## Relevant Memory');
+    expect(result).toContain('User prefers TypeScript');
+    expect(result).toContain('## Active Skills');
+    expect(result).toContain('dot-ai skill content');
+    expect(result).toContain('## Available Tools');
+    expect(result).toContain('bash');
+  });
+
+  it('skips identities when skipIdentities: true', () => {
+    const ctx = makeContext({
+      identities: [makeIdentity({ content: 'You are Kiwi.' })],
+      memories: [makeMemory({ content: 'Some memory' })],
+    });
+
+    const result = formatContext(ctx, { skipIdentities: true });
+
+    expect(result).not.toContain('You are Kiwi.');
+    expect(result).toContain('## Relevant Memory');
+  });
+
+  it('includes identities when skipIdentities: false', () => {
+    const ctx = makeContext({
+      identities: [makeIdentity({ content: 'You are Kiwi.' })],
+    });
+
+    const result = formatContext(ctx, { skipIdentities: false });
+
+    expect(result).toContain('You are Kiwi.');
+  });
+
+  it('includes identities when skipIdentities is undefined (backward compat)', () => {
+    const ctx = makeContext({
+      identities: [makeIdentity({ content: 'You are Kiwi.' })],
+    });
+
+    const result = formatContext(ctx);
+
+    expect(result).toContain('You are Kiwi.');
+  });
+
+  it('sorts identities by priority descending', () => {
+    const ctx = makeContext({
+      identities: [
+        makeIdentity({ content: 'Low priority identity.', priority: 1 }),
+        makeIdentity({ content: 'High priority identity.', priority: 100 }),
+      ],
+    });
+
+    const result = formatContext(ctx);
+    const highPos = result.indexOf('High priority identity.');
+    const lowPos = result.indexOf('Low priority identity.');
+
+    expect(highPos).toBeLessThan(lowPos);
+  });
+
+  it('truncates skill content at maxSkillLength with [...truncated] marker', () => {
+    const longContent = 'A'.repeat(200);
+    const ctx = makeContext({
+      skills: [makeSkill({ content: longContent })],
+    });
+
+    const result = formatContext(ctx, { maxSkillLength: 50 });
+
+    expect(result).toContain('A'.repeat(50));
+    expect(result).toContain('[...truncated]');
+    expect(result).not.toContain('A'.repeat(51));
+  });
+
+  it('does not truncate skill content shorter than maxSkillLength', () => {
+    const ctx = makeContext({
+      skills: [makeSkill({ content: 'Short content.' })],
+    });
+
+    const result = formatContext(ctx, { maxSkillLength: 200 });
+
+    expect(result).toContain('Short content.');
+    expect(result).not.toContain('[...truncated]');
+  });
+
+  it('limits number of skills to maxSkills', () => {
+    const ctx = makeContext({
+      skills: [
+        makeSkill({ name: 'skill-a', content: 'Content A' }),
+        makeSkill({ name: 'skill-b', content: 'Content B' }),
+        makeSkill({ name: 'skill-c', content: 'Content C' }),
+      ],
+    });
+
+    const result = formatContext(ctx, { maxSkills: 2 });
+
+    expect(result).toContain('skill-a');
+    expect(result).toContain('Content A');
+    expect(result).toContain('skill-b');
+    expect(result).toContain('Content B');
+    expect(result).not.toContain('skill-c');
+    expect(result).not.toContain('Content C');
+  });
+
+  it('combines skipIdentities + maxSkillLength + maxSkills', () => {
+    const ctx = makeContext({
+      identities: [makeIdentity({ content: 'You are Kiwi.' })],
+      skills: [
+        makeSkill({ name: 'skill-a', content: 'A'.repeat(100) }),
+        makeSkill({ name: 'skill-b', content: 'B'.repeat(100) }),
+        makeSkill({ name: 'skill-c', content: 'C'.repeat(100) }),
+      ],
+    });
+
+    const result = formatContext(ctx, {
+      skipIdentities: true,
+      maxSkillLength: 20,
+      maxSkills: 2,
+    });
+
+    expect(result).not.toContain('You are Kiwi.');
+    expect(result).toContain('skill-a');
+    expect(result).toContain('skill-b');
+    expect(result).not.toContain('skill-c');
+    expect(result).toContain('[...truncated]');
+    expect(result).not.toContain('A'.repeat(21));
+  });
+
+  it('returns empty string when context has all empty arrays', () => {
+    const ctx = makeContext();
+
+    const result = formatContext(ctx);
+
+    expect(result).toBe('');
+  });
+
+  it('omits routing section when model is "default"', () => {
+    const ctx = makeContext({
+      routing: { model: 'default', reason: 'no routing needed' },
+    });
+
+    const result = formatContext(ctx);
+
+    expect(result).not.toContain('## Model Routing');
+  });
+
+  it('includes routing section when model is not "default"', () => {
+    const ctx = makeContext({
+      routing: { model: 'opus', reason: 'complex task' },
+    });
+
+    const result = formatContext(ctx);
+
+    expect(result).toContain('## Model Routing');
+    expect(result).toContain('opus');
+    expect(result).toContain('complex task');
+  });
+
+  it('separates multiple sections with ---', () => {
+    const ctx = makeContext({
+      identities: [makeIdentity({ content: 'Identity content.' })],
+      memories: [makeMemory({ content: 'A memory.' })],
+    });
+
+    const result = formatContext(ctx);
+
+    expect(result).toContain('---');
+  });
+
+  it('skips skills without content', () => {
+    const ctx = makeContext({
+      skills: [
+        makeSkill({ name: 'no-content', content: undefined }),
+        makeSkill({ name: 'has-content', content: 'Real content' }),
+      ],
+    });
+
+    const result = formatContext(ctx);
+
+    expect(result).toContain('has-content');
+    expect(result).toContain('Real content');
+    expect(result).not.toContain('no-content');
+  });
+});

package/src/__tests__/labels.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect } from 'vitest';
+import { extractLabels, buildVocabulary } from '../labels.js';
+
+describe('extractLabels', () => {
+  it('returns matched labels from vocabulary', () => {
+    const labels = extractLabels('I need to fix the memory issue', ['memory', 'routing', 'skills']);
+    expect(labels).toHaveLength(1);
+    expect(labels[0]).toEqual({ name: 'memory', source: 'extract' });
+  });
+
+  it('returns multiple matches when several vocabulary words are present', () => {
+    const labels = extractLabels('routing and memory both matter', ['memory', 'routing', 'skills']);
+    expect(labels).toHaveLength(2);
+    const names = labels.map((l) => l.name);
+    expect(names).toContain('memory');
+    expect(names).toContain('routing');
+  });
+
+  it('returns empty array when no vocabulary words match', () => {
+    const labels = extractLabels('hello world', ['memory', 'routing', 'skills']);
+    expect(labels).toHaveLength(0);
+  });
+
+  it('is case insensitive', () => {
+    const labels = extractLabels('MEMORY is important', ['memory']);
+    expect(labels).toHaveLength(1);
+    expect(labels[0].name).toBe('memory');
+  });
+
+  it('is case insensitive for vocabulary words too', () => {
+    const labels = extractLabels('memory is important', ['Memory']);
+    expect(labels).toHaveLength(1);
+    expect(labels[0].name).toBe('Memory');
+  });
+
+  it('sets source to "extract" for all labels', () => {
+    const labels = extractLabels('use routing for memory', ['routing', 'memory']);
+    for (const label of labels) {
+      expect(label.source).toBe('extract');
+    }
+  });
+
+  it('returns empty array when vocabulary is empty', () => {
+    const labels = extractLabels('any prompt at all', []);
+    expect(labels).toHaveLength(0);
+  });
+
+  it('does not match partial words within a prompt', () => {
+    const labels = extractLabels('my skillset is broad', ['skill']);
+    expect(labels).toHaveLength(0);
+  });
+
+  it('matches whole words at word boundaries', () => {
+    const labels = extractLabels('my skill is broad', ['skill']);
+    expect(labels).toHaveLength(1);
+    expect(labels[0].name).toBe('skill');
+  });
+});
+
+describe('buildVocabulary', () => {
+  it('merges skill labels and tool labels into a flat array', () => {
+    const vocab = buildVocabulary([['memory', 'routing']], [['ui', 'ux']]);
+    expect(vocab).toContain('memory');
+    expect(vocab).toContain('routing');
+    expect(vocab).toContain('ui');
+    expect(vocab).toContain('ux');
+  });
+
+  it('deduplicates labels appearing in multiple skills', () => {
+    const vocab = buildVocabulary([['memory', 'routing'], ['memory', 'skills']], []);
+    const memoryCount = vocab.filter((v) => v === 'memory').length;
+    expect(memoryCount).toBe(1);
+  });
+
+  it('deduplicates labels appearing across skills and tools', () => {
+    const vocab = buildVocabulary([['shared']], [['shared']]);
+    const count = vocab.filter((v) => v === 'shared').length;
+    expect(count).toBe(1);
+  });
+
+  it('returns empty array when both inputs are empty', () => {
+    const vocab = buildVocabulary([], []);
+    expect(vocab).toHaveLength(0);
+  });
+
+  it('handles empty skill label arrays', () => {
+    const vocab = buildVocabulary([[], []], [['tool-label']]);
+    expect(vocab).toEqual(['tool-label']);
+  });
+
+  it('returns unique values only', () => {
+    const vocab = buildVocabulary([['a', 'b', 'a']], [['b', 'c']]);
+    expect(vocab.length).toBe(3);
+    expect(new Set(vocab).size).toBe(3);
+  });
+});