@dot-ai/core 0.5.2 → 0.8.0

package/src/__tests__/loader.test.ts

@@ -1,191 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { registerProvider, clearProviders, createProviders } from '../loader.js';
-
-beforeEach(() => {
-  clearProviders();
-});
-
-describe('clearProviders', () => {
-  it('resets the registry so registered factories are no longer used', async () => {
-    const factory = vi.fn().mockReturnValue({
-      search: vi.fn().mockResolvedValue([{ content: 'custom', type: 'fact', source: 'test' }]),
-      store: vi.fn().mockResolvedValue(undefined),
-    });
-    registerProvider('@dot-ai/provider-file-memory', factory);
-    clearProviders();
-
-    const providers = await createProviders({ memory: { use: '@dot-ai/provider-file-memory' } });
-    // After clear, factory should not be called — noop provider is used
-    expect(factory).not.toHaveBeenCalled();
-    const memories = await providers.memory.search('query');
-    expect(memories).toEqual([]);
-  });
-});
-
-describe('registerProvider + createProviders', () => {
-  it('uses registered memory factory', async () => {
-    const customMemory = {
-      search: vi.fn().mockResolvedValue([{ content: 'custom result', type: 'fact', source: 'test' }]),
-      store: vi.fn().mockResolvedValue(undefined),
-    };
-    registerProvider('@dot-ai/custom-memory', () => customMemory);
-
-    const providers = await createProviders({ memory: { use: '@dot-ai/custom-memory' } });
-    const results = await providers.memory.search('query');
-    expect(results[0]?.content).toBe('custom result');
-  });
-
-  it('passes options to the factory', async () => {
-    const factory = vi.fn().mockReturnValue({
-      search: vi.fn().mockResolvedValue([]),
-      store: vi.fn().mockResolvedValue(undefined),
-    });
-    registerProvider('@dot-ai/opts-memory', factory);
-
-    await createProviders({ memory: { use: '@dot-ai/opts-memory', with: { url: 'http://test' } } });
-    expect(factory).toHaveBeenCalledWith({ url: 'http://test' });
-  });
-
-  it('supports async factory (returns Promise)', async () => {
-    const customMemory = {
-      search: vi.fn().mockResolvedValue([]),
-      store: vi.fn().mockResolvedValue(undefined),
-    };
-    registerProvider('@dot-ai/async-memory', async () => customMemory);
-
-    const providers = await createProviders({ memory: { use: '@dot-ai/async-memory' } });
-    expect(providers.memory).toBe(customMemory);
-  });
-
-  it('registers and uses a skill provider', async () => {
-    const mockSkills = [{ name: 'my-skill', description: 'A skill', labels: ['test'] }];
-    registerProvider('@dot-ai/custom-skills', () => ({
-      list: vi.fn().mockResolvedValue(mockSkills),
-      match: vi.fn().mockResolvedValue([]),
-      load: vi.fn().mockResolvedValue(null),
-    }));
-
-    const providers = await createProviders({ skills: { use: '@dot-ai/custom-skills' } });
-    const skills = await providers.skills.list();
-    expect(skills).toEqual(mockSkills);
-  });
-
-  it('registers and uses an identity provider', async () => {
-    const mockIdentities = [{ type: 'agents', content: 'I am Kiwi', source: 'file', priority: 1 }];
-    registerProvider('@dot-ai/custom-identity', () => ({
-      load: vi.fn().mockResolvedValue(mockIdentities),
-    }));
-
-    const providers = await createProviders({ identity: { use: '@dot-ai/custom-identity' } });
-    const identities = await providers.identity.load();
-    expect(identities).toEqual(mockIdentities);
-  });
-});
-
-describe('auto-discovery via dynamic import', () => {
-  // NOTE: Dynamic import behavior is hard to mock reliably in vitest (import() is
-  // module-level). Auto-discovery with real packages is tested via E2E.
-  // The unit guarantee here is that an unknown provider name gracefully falls
-  // back to the noop implementation (i.e. tryImportProvider returns null for
-  // non-existent packages without throwing).
-  it('falls back to noop when provider package does not exist', async () => {
-    // '@dot-ai/nonexistent-provider' is not registered and cannot be imported
-    const providers = await createProviders({ memory: { use: '@dot-ai/nonexistent-provider' } });
-    const memories = await providers.memory.search('query');
-    expect(memories).toEqual([]);
-  });
-});
-
-describe('createProviders — noop fallbacks', () => {
-  // Use non-existent provider names to ensure noop fallbacks are returned
-  // (auto-discovery would find real packages for default names like @dot-ai/provider-file-memory)
-  const noopConfig = {
-    memory: { use: '@dot-ai/nonexistent-memory' },
-    skills: { use: '@dot-ai/nonexistent-skills' },
-    identity: { use: '@dot-ai/nonexistent-identity' },
-    routing: { use: '@dot-ai/nonexistent-routing' },
-    tasks: { use: '@dot-ai/nonexistent-tasks' },
-    tools: { use: '@dot-ai/nonexistent-tools' },
-  };
-
-  it('returns noop memory provider when nothing registered', async () => {
-    const providers = await createProviders(noopConfig);
-    const memories = await providers.memory.search('any query');
-    expect(memories).toEqual([]);
-  });
-
-  it('noop memory.store resolves without error', async () => {
-    const providers = await createProviders(noopConfig);
-    await expect(
-      providers.memory.store({ content: 'x', type: 'log' }),
-    ).resolves.toBeUndefined();
-  });
-
-  it('noop skills.list returns empty array', async () => {
-    const providers = await createProviders(noopConfig);
-    expect(await providers.skills.list()).toEqual([]);
-  });
-
-  it('noop skills.match returns empty array', async () => {
-    const providers = await createProviders(noopConfig);
-    expect(await providers.skills.match([])).toEqual([]);
-  });
-
-  it('noop skills.load returns null', async () => {
-    const providers = await createProviders(noopConfig);
-    expect(await providers.skills.load('any-skill')).toBeNull();
-  });
-
-  it('noop identity.load returns empty array', async () => {
-    const providers = await createProviders(noopConfig);
-    expect(await providers.identity.load()).toEqual([]);
-  });
-
-  it('noop routing.route returns a RoutingResult', async () => {
-    const providers = await createProviders(noopConfig);
-    const result = await providers.routing.route([]);
-    expect(result).toHaveProperty('model');
-    expect(result).toHaveProperty('reason');
-    expect(typeof result.model).toBe('string');
-  });
-
-  it('noop tasks.list returns empty array', async () => {
-    const providers = await createProviders(noopConfig);
-    expect(await providers.tasks.list()).toEqual([]);
-  });
-
-  it('noop tasks.get returns null', async () => {
-    const providers = await createProviders(noopConfig);
-    expect(await providers.tasks.get('123')).toBeNull();
-  });
-
-  it('noop tasks.create returns a task with generated id', async () => {
-    const providers = await createProviders(noopConfig);
-    const task = await providers.tasks.create({ text: 'Do something', status: 'pending' });
-    expect(task).toHaveProperty('id');
-    expect(task.text).toBe('Do something');
-    expect(task.status).toBe('pending');
-  });
-
-  it('noop tasks.update returns a task with the patched fields', async () => {
-    const providers = await createProviders(noopConfig);
-    const task = await providers.tasks.update('abc', { status: 'done' });
-    expect(task.id).toBe('abc');
-    expect(task.status).toBe('done');
-  });
-
-  it('noop tools.list returns empty array', async () => {
-    const providers = await createProviders(noopConfig);
-    expect(await providers.tools.list()).toEqual([]);
-  });
-
-  it('noop tools.match returns empty array', async () => {
-    const providers = await createProviders(noopConfig);
-    expect(await providers.tools.match([])).toEqual([]);
-  });
-
-  it('noop tools.load returns null', async () => {
-    const providers = await createProviders(noopConfig);
-    expect(await providers.tools.load('any-tool')).toBeNull();
-  });
-});

package/src/contracts.ts

@@ -1,71 +0,0 @@
-import type {
-  MemoryEntry,
-  Skill,
-  Identity,
-  Tool,
-  Task,
-  TaskFilter,
-  RoutingResult,
-  Label,
-} from './types.js';
-
-/**
- * Memory provider — search and store memories.
- * Implementation decides WHERE and HOW (files, DB, API, etc.)
- */
-export interface MemoryProvider {
-  search(query: string, labels?: string[]): Promise<MemoryEntry[]>;
-  store(entry: Omit<MemoryEntry, 'source'>): Promise<void>;
-}
-
-/**
- * Skill provider — discover and load skills.
- * Implementation decides WHERE skills come from (files, registry, API, etc.)
- */
-export interface SkillProvider {
-  list(): Promise<Skill[]>;
-  match(labels: Label[]): Promise<Skill[]>;
-  load(name: string): Promise<string | null>; // returns content
-}
-
-/**
- * Identity provider — load identity documents.
- * Implementation decides format and source.
- */
-export interface IdentityProvider {
-  load(): Promise<Identity[]>;
-}
-
-/**
- * Routing provider — decide which model to use.
- * Implementation decides the logic (rules, LLM, etc.)
- */
-export interface RoutingProvider {
-  route(labels: Label[], context?: Record<string, unknown>): Promise<RoutingResult>;
-}
-
-/**
- * Task provider — CRUD for tasks.
- * Implementation decides storage (files, Cockpit API, Jira, etc.)
- */
-export interface TaskProvider {
-  list(filter?: TaskFilter): Promise<Task[]>;
-  get(id: string): Promise<Task | null>;
-  create(task: Omit<Task, 'id'>): Promise<Task>;
-  update(id: string, patch: Partial<Task>): Promise<Task>;
-}
-
-/**
- * Tool provider — discover and match tools.
- * Implementation decides source (MCP config, files, registry, etc.)
- */
-export interface ToolProvider {
-  list(): Promise<Tool[]>;
-  match(labels: Label[]): Promise<Tool[]>;
-  load(name: string): Promise<Tool | null>;
-}
-
-/**
- * Factory function type for creating providers from config.
- */
-export type ProviderFactory<T> = (options: Record<string, unknown>) => T | Promise<T>;

package/src/engine.ts

@@ -1,145 +0,0 @@
-import type {
-  MemoryProvider,
-  SkillProvider,
-  IdentityProvider,
-  RoutingProvider,
-  TaskProvider,
-  ToolProvider,
-} from './contracts.js';
-import type { EnrichedContext, Identity, Skill } from './types.js';
-import type { Logger } from './logger.js';
-import { extractLabels, buildVocabulary } from './labels.js';
-
-/**
- * All providers needed by the engine.
- */
-export interface Providers {
-  memory: MemoryProvider;
-  skills: SkillProvider;
-  identity: IdentityProvider;
-  routing: RoutingProvider;
-  tasks: TaskProvider;
-  tools: ToolProvider;
-}
-
-/**
- * Cached data from boot phase. Reused across prompts.
- */
-export interface BootCache {
-  identities: Identity[];
-  vocabulary: string[];
-  skills: Skill[];
-}
-
-/**
- * Boot phase — run once per session.
- * Loads identities, indexes skills/tools, builds label vocabulary.
- */
-export async function boot(providers: Providers, logger?: Logger): Promise<BootCache> {
-  const start = performance.now();
-
-  const [identities, skills, tools] = await Promise.all([
-    providers.identity.load(),
-    providers.skills.list(),
-    providers.tools.list(),
-  ]);
-
-  // Build vocabulary from skill labels, skill triggers (excluding meta-triggers), and tool labels
-  const META_TRIGGERS = new Set(['always', 'auto', 'manual', 'boot', 'heartbeat', 'pipeline', 'audit']);
-  const skillTriggers = skills.map((s) =>
-    (s.triggers ?? []).filter((t) => !META_TRIGGERS.has(t)),
-  );
-
-  const vocabulary = buildVocabulary(
-    [...skills.map((s) => s.labels), ...skillTriggers],
-    tools.map((t) => t.labels),
-  );
-
-  logger?.log({
-    timestamp: new Date().toISOString(),
-    level: 'info',
-    phase: 'boot',
-    event: 'boot_complete',
-    data: { identityCount: identities.length, skillCount: skills.length, vocabularySize: vocabulary.length },
-    durationMs: Math.round(performance.now() - start),
-  });
-
-  return { identities, vocabulary, skills };
-}
-
-/**
- * Enrich a prompt — run per prompt.
- * Calls all providers to build an EnrichedContext.
- */
-export async function enrich(
-  prompt: string,
-  providers: Providers,
-  cache: BootCache,
-  logger?: Logger,
-): Promise<EnrichedContext> {
-  const start = performance.now();
-
-  // 1. Extract labels from prompt against known vocabulary
-  const labels = extractLabels(prompt, cache.vocabulary);
-
-  logger?.log({
-    timestamp: new Date().toISOString(),
-    level: 'info',
-    phase: 'enrich',
-    event: 'labels_extracted',
-    data: { labels: labels.map(l => l.name), vocabularySize: cache.vocabulary.length },
-    durationMs: Math.round(performance.now() - start),
-  });
-
-  // 2. Search memory + match skills + match tools + route — all in parallel
-  const [memories, matchedSkills, matchedTools, routing] = await Promise.all([
-    providers.memory.search(prompt, labels.map((l) => l.name)),
-    providers.skills.match(labels),
-    providers.tools.match(labels),
-    providers.routing.route(labels),
-  ]);
-
-  logger?.log({
-    timestamp: new Date().toISOString(),
-    level: 'info',
-    phase: 'enrich',
-    event: 'enrich_complete',
-    data: {
-      labelCount: labels.length,
-      memoryCount: memories.length,
-      skillCount: matchedSkills.length,
-      routing: routing.model,
-    },
-    durationMs: Math.round(performance.now() - start),
-  });
-
-  return {
-    prompt,
-    labels,
-    identities: cache.identities,
-    memories,
-    skills: matchedSkills,
-    tools: matchedTools,
-    routing,
-  };
-}
-
-/**
- * Learn phase — run after agent response.
- * Stores learnings in memory.
- */
-export async function learn(
-  response: string,
-  providers: Providers,
-): Promise<void> {
-  const MAX_LEARN_LENGTH = 500;
-  const truncated = response.length > MAX_LEARN_LENGTH
-    ? response.slice(0, MAX_LEARN_LENGTH) + '…'
-    : response;
-
-  await providers.memory.store({
-    content: truncated,
-    type: 'log',
-    date: new Date().toISOString().slice(0, 10),
-  });
-}

package/src/loader.ts

@@ -1,152 +0,0 @@
-import type { DotAiConfig, Task } from './types.js';
-import type {
-  MemoryProvider,
-  SkillProvider,
-  IdentityProvider,
-  RoutingProvider,
-  TaskProvider,
-  ToolProvider,
-} from './contracts.js';
-import type { Providers } from './engine.js';
-import { resolveConfig } from './config.js';
-/**
- * Registry of provider factories.
- * Adapters register their providers here before boot.
- */
-const registry = new Map<string, (options: Record<string, unknown>) => unknown>();
-
-/**
- * Register a provider factory.
- * Call this before createProviders().
- *
- * @example
- * registerProvider('@dot-ai/cockpit-memory', (opts) => new CockpitMemory(opts.url));
- */
-export function registerProvider(
-  name: string,
-  factory: (options: Record<string, unknown>) => unknown,
-): void {
-  registry.set(name, factory);
-}
-
-/**
- * Clear all registered providers.
- * Useful for testing.
- */
-export function clearProviders(): void {
-  registry.clear();
-}
-
-/**
- * Register all default file-based providers.
- * Call this at startup if you want file-based defaults available.
- */
-export function registerDefaults(): void {
-  // Default providers are now separate packages (@dot-ai/provider-file-memory, etc.)
-  // They are resolved via auto-discovery in resolve() → tryImportProvider()
-  // No explicit registration needed — the package names match the config defaults.
-}
-
-/**
- * Create all providers from config.
- * Falls back to no-op providers for any missing registration.
- */
-export async function createProviders(config: DotAiConfig): Promise<Providers> {
-  const resolved = resolveConfig(config);
-
-  return {
-    memory: await resolve<MemoryProvider>(resolved.memory.use, resolved.memory.with ?? {}, noopMemory),
-    skills: await resolve<SkillProvider>(resolved.skills.use, resolved.skills.with ?? {}, noopSkills),
-    identity: await resolve<IdentityProvider>(resolved.identity.use, resolved.identity.with ?? {}, noopIdentity),
-    routing: await resolve<RoutingProvider>(resolved.routing.use, resolved.routing.with ?? {}, noopRouting),
-    tasks: await resolve<TaskProvider>(resolved.tasks.use, resolved.tasks.with ?? {}, noopTasks),
-    tools: await resolve<ToolProvider>(resolved.tools.use, resolved.tools.with ?? {}, noopTools),
-  };
-}
-
-async function resolve<T>(name: string, options: Record<string, unknown>, fallback: T): Promise<T> {
-  let factory = registry.get(name);
-
-  if (!factory) {
-    // Auto-discovery: try dynamic import
-    factory = await tryImportProvider(name);
-    if (factory) {
-      registry.set(name, factory); // Cache for next time
-    }
-  }
-
-  if (!factory) return fallback;
-  return factory(options) as T;
-}
-
-/**
- * Try to import a provider package dynamically.
- * Looks for: default export factory, createXxxProvider function, or XxxProvider class.
- */
-async function tryImportProvider(
-  name: string,
-): Promise<((options: Record<string, unknown>) => unknown) | undefined> {
-  try {
-    const mod = await import(name);
-
-    // 1. Check for default export (function)
-    if (typeof mod.default === 'function') {
-      return mod.default as (options: Record<string, unknown>) => unknown;
-    }
-
-    // 2. Check for createXxxProvider factory function
-    for (const [key, value] of Object.entries(mod)) {
-      if (key.startsWith('create') && key.endsWith('Provider') && typeof value === 'function') {
-        return value as (options: Record<string, unknown>) => unknown;
-      }
-    }
-
-    // 3. Check for XxxProvider class (constructor)
-    for (const [key, value] of Object.entries(mod)) {
-      if (key.endsWith('Provider') && typeof value === 'function') {
-        return (opts: Record<string, unknown>) => new (value as new (opts: Record<string, unknown>) => unknown)(opts);
-      }
-    }
-
-    return undefined;
-  } catch {
-    // Package not found or import error — not a problem, fall back to noop
-    return undefined;
-  }
-}
-
-// ── No-op providers (safe fallbacks) ────────────────────────────────────────
-
-const noopMemory: MemoryProvider = {
-  async search(_query: string, _labels?: string[]) { return []; },
-  async store(_entry) {},
-};
-
-const noopSkills: SkillProvider = {
-  async list() { return []; },
-  async match(_labels) { return []; },
-  async load(_name: string) { return null; },
-};
-
-const noopIdentity: IdentityProvider = {
-  async load() { return []; },
-};
-
-const noopRouting: RoutingProvider = {
-  async route(_labels) { return { model: 'default', reason: 'no routing provider' }; },
-};
-
-const noopTasks: TaskProvider = {
-  async list(_filter?) { return []; },
-  async get(_id: string) { return null; },
-  async create(task): Promise<Task> { return { id: crypto.randomUUID(), ...task }; },
-  async update(id: string, patch: Partial<Task>): Promise<Task> {
-    return { id, text: '', status: '', ...patch };
-  },
-};
-
-const noopTools: ToolProvider = {
-  async list() { return []; },
-  async match(_labels) { return []; },
-  async load(_name: string) { return null; },
-};