@dot-ai/core 0.9.0 → 0.11.0

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

@@ -0,0 +1,237 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdir, writeFile, rm, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  listPackages,
+  resolvePackages,
+  ensurePackagesInstalled,
+} from '../package-manager.js';
+
+// Use temp directory for test fixtures
+const testDir = join(tmpdir(), 'dot-ai-pkg-test-' + Date.now());
+
+beforeEach(async () => {
+  await mkdir(join(testDir, '.ai', 'packages'), { recursive: true });
+});
+
+afterEach(async () => {
+  await rm(testDir, { recursive: true, force: true });
+});
+
+// ── Helper: create a fake installed package ─────────────────────────────────
+async function createFakePackage(
+  name: string,
+  version: string,
+  dotAi?: { extensions?: string[] },
+) {
+  const installDir = join(testDir, '.ai', 'packages');
+  const pkgDir = join(installDir, 'node_modules', name);
+  await mkdir(pkgDir, { recursive: true });
+
+  // Write package.json for installed package
+  const pkgJson: Record<string, unknown> = { name, version };
+  if (dotAi) pkgJson['dot-ai'] = dotAi;
+  await writeFile(join(pkgDir, 'package.json'), JSON.stringify(pkgJson));
+
+  // Create extension files if declared
+  if (dotAi?.extensions) {
+    for (const ext of dotAi.extensions) {
+      const extPath = join(pkgDir, ext);
+      await mkdir(join(extPath, '..'), { recursive: true });
+      await writeFile(extPath, 'export default function() {}');
+    }
+  }
+
+  // Update the packages/package.json dependencies
+  const depsPkgPath = join(installDir, 'package.json');
+  let deps: Record<string, string> = {};
+  try {
+    const raw = await readFile(depsPkgPath, 'utf-8');
+    const existing = JSON.parse(raw);
+    deps = existing.dependencies ?? {};
+  } catch { /* no file yet */ }
+
+  deps[name] = version;
+  await writeFile(depsPkgPath, JSON.stringify({ dependencies: deps }));
+}
+
+describe('listPackages', () => {
+  it('returns empty array when no packages installed', async () => {
+    const result = await listPackages(testDir);
+    expect(result).toEqual([]);
+  });
+
+  it('lists installed packages with dot-ai field', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0', {
+      extensions: ['./dist/extension.js'],
+    });
+
+    const result = await listPackages(testDir);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe('@dot-ai/ext-memory');
+    expect(result[0].version).toBe('1.0.0');
+    expect(result[0].dotAi?.extensions).toEqual(['./dist/extension.js']);
+  });
+
+  it('lists packages without dot-ai field', async () => {
+    await createFakePackage('some-lib', '2.0.0');
+
+    const result = await listPackages(testDir);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe('some-lib');
+    expect(result[0].dotAi).toBeUndefined();
+  });
+
+  it('lists multiple packages', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0', {
+      extensions: ['./dist/extension.js'],
+    });
+    await createFakePackage('@dot-ai/ext-identity', '1.0.0', {
+      extensions: ['./dist/index.js'],
+    });
+
+    const result = await listPackages(testDir);
+    expect(result).toHaveLength(2);
+  });
+});
+
+describe('resolvePackages', () => {
+  it('returns empty when no packages', async () => {
+    const result = await resolvePackages(testDir);
+    expect(result.extensions).toEqual([]);
+    expect(result.skills).toEqual([]);
+    expect(result.providers).toEqual([]);
+  });
+
+  it('resolves extension paths from packages with dot-ai field', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0', {
+      extensions: ['./dist/extension.js'],
+    });
+
+    const result = await resolvePackages(testDir);
+    expect(result.extensions).toHaveLength(1);
+    expect(result.extensions[0]).toContain('ext-memory');
+    expect(result.extensions[0]).toContain('dist/extension.js');
+  });
+
+  it('skips packages without dot-ai field', async () => {
+    await createFakePackage('some-lib', '2.0.0');
+
+    const result = await resolvePackages(testDir);
+    expect(result.extensions).toHaveLength(0);
+  });
+});
+
+describe('ensurePackagesInstalled', () => {
+  it('skips already installed packages', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0', {
+      extensions: ['./dist/extension.js'],
+    });
+
+    const result = await ensurePackagesInstalled(
+      testDir,
+      ['@dot-ai/ext-memory'],
+    );
+
+    expect(result.skipped).toContain('@dot-ai/ext-memory');
+    expect(result.installed).toHaveLength(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('skips packages when onMissing returns skip', async () => {
+    const result = await ensurePackagesInstalled(
+      testDir,
+      ['@dot-ai/ext-not-there'],
+      async () => 'skip',
+    );
+
+    expect(result.skipped).toContain('@dot-ai/ext-not-there');
+    expect(result.installed).toHaveLength(0);
+  });
+
+  it('errors when onMissing returns error', async () => {
+    const result = await ensurePackagesInstalled(
+      testDir,
+      ['@dot-ai/ext-not-there'],
+      async () => 'error',
+    );
+
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].source).toBe('@dot-ai/ext-not-there');
+    expect(result.errors[0].error).toContain('Missing package');
+  });
+
+  it('reports errors for failed installs', async () => {
+    // Use an impossible package name that npm will fail to find
+    const result = await ensurePackagesInstalled(
+      testDir,
+      ['@dot-ai-fake-nonexistent-pkg-xyz/no-exist'],
+    );
+
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].source).toBe('@dot-ai-fake-nonexistent-pkg-xyz/no-exist');
+  });
+
+  it('handles npm: prefix in source', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0', {
+      extensions: ['./dist/extension.js'],
+    });
+
+    const result = await ensurePackagesInstalled(
+      testDir,
+      ['npm:@dot-ai/ext-memory@1.0.0'],
+    );
+
+    // npm:@dot-ai/ext-memory@1.0.0 → name = @dot-ai/ext-memory → already installed
+    expect(result.skipped).toContain('npm:@dot-ai/ext-memory@1.0.0');
+  });
+
+  it('handles multiple packages', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0', {
+      extensions: ['./dist/extension.js'],
+    });
+
+    const result = await ensurePackagesInstalled(
+      testDir,
+      ['@dot-ai/ext-memory', '@dot-ai/ext-not-there'],
+      async (source) => source.includes('not-there') ? 'skip' : 'install',
+    );
+
+    expect(result.skipped).toContain('@dot-ai/ext-memory');
+    expect(result.skipped).toContain('@dot-ai/ext-not-there');
+  });
+});
+
+describe('parsePackageSource (via ensurePackagesInstalled)', () => {
+  // We test parsePackageSource indirectly through ensurePackagesInstalled
+
+  it('handles scoped package with version', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0');
+
+    const result = await ensurePackagesInstalled(testDir, ['@dot-ai/ext-memory@1.0.0']);
+    // Should find it as already installed (strips version to get name)
+    expect(result.skipped).toContain('@dot-ai/ext-memory@1.0.0');
+  });
+
+  it('handles scoped package without version', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0');
+
+    const result = await ensurePackagesInstalled(testDir, ['@dot-ai/ext-memory']);
+    expect(result.skipped).toContain('@dot-ai/ext-memory');
+  });
+
+  it('handles unscoped package with version', async () => {
+    await createFakePackage('my-ext', '2.0.0');
+
+    const result = await ensurePackagesInstalled(testDir, ['my-ext@2.0.0']);
+    expect(result.skipped).toContain('my-ext@2.0.0');
+  });
+
+  it('handles npm: prefix with scoped package', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0');
+
+    const result = await ensurePackagesInstalled(testDir, ['npm:@dot-ai/ext-memory']);
+    expect(result.skipped).toContain('npm:@dot-ai/ext-memory');
+  });
+});

package/src/__tests__/runtime.test.ts

@@ -26,23 +26,24 @@ describe('DotAiRuntime', () => {
   });
 
   describe('processPrompt', () => {
-    it('returns sections, labels, formatted, enriched, capabilities', async () => {
+    it('returns sections, labels, routing', async () => {
       const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
       await runtime.boot();
       const result = await runtime.processPrompt('hello world');
-      expect(result.formatted).toBeDefined();
-      expect(result.enriched).toBeDefined();
-      expect(result.capabilities).toBeDefined();
       expect(result.labels).toBeDefined();
       expect(result.sections).toBeDefined();
+      expect(Array.isArray(result.sections)).toBe(true);
+      expect(result.routing).toBeDefined();
     });
-  });
 
-  describe('learn', () => {
-    it('fires agent_end without throwing', async () => {
+    it('includes core system section', async () => {
       const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
       await runtime.boot();
-      await runtime.learn('test response');
+      const result = await runtime.processPrompt('hello');
+      const systemSection = result.sections.find(s => s.id === 'dot-ai:system');
+      expect(systemSection).toBeDefined();
+      expect(systemSection!.priority).toBe(95);
+      expect(systemSection!.source).toBe('core');
     });
   });
 
@@ -74,6 +75,19 @@ describe('DotAiRuntime', () => {
     });
   });
 
+  describe('executeTool', () => {
+    it('throws when not booted', async () => {
+      const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
+      await expect(runtime.executeTool('test', {})).rejects.toThrow('Runtime not booted');
+    });
+
+    it('throws for unknown tool', async () => {
+      const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
+      await runtime.boot();
+      await expect(runtime.executeTool('nonexistent', {})).rejects.toThrow('Tool not found');
+    });
+  });
+
   describe('shutdown', () => {
     it('fires session_end and flushes', async () => {
       const flushFn = vi.fn().mockResolvedValue(undefined);
@@ -122,12 +136,26 @@ describe('DotAiRuntime', () => {
       expect(runtime.commands).toEqual([]);
     });
 
-    it('diagnostics include vocabulary size', async () => {
+    it('skills returns empty array when no extensions', async () => {
+      const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
+      await runtime.boot();
+      expect(runtime.skills).toEqual([]);
+    });
+
+    it('identities returns empty array when no extensions', async () => {
+      const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
+      await runtime.boot();
+      expect(runtime.identities).toEqual([]);
+    });
+
+    it('diagnostics include vocabulary size and counts', async () => {
       const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
       await runtime.boot();
       const diag = runtime.diagnostics;
       expect(diag.vocabularySize).toBeDefined();
-      expect(diag.capabilityCount).toBe(0); // no extensions = no tools
+      expect(diag.capabilityCount).toBe(0);
+      expect(diag.skillCount).toBe(0);
+      expect(diag.identityCount).toBe(0);
       expect(diag.extensions).toEqual([]);
     });
 

package/src/boot-cache.ts

@@ -11,7 +11,7 @@ export interface BootCacheData {
   version: 1;
   /** Checksum of inputs that produced this cache */
   checksum: string;
-  /** Label vocabulary from resources_discover */
+  /** Label vocabulary from registered resources */
   vocabulary: string[];
   /** Extension paths that were loaded */
   extensionPaths: string[];

package/src/extension-api.ts

@@ -1,22 +1,19 @@
 import type {
-  ContextInjectEvent, ContextInjectResult,
-  ContextModifyEvent, ContextModifyResult,
   ToolCallEvent, ToolCallResult,
   ToolResultEvent,
   AgentEndEvent,
   ToolDefinition,
   ExtensionContext,
-  ResourcesDiscoverResult,
   LabelExtractEvent,
   ContextEnrichEvent, ContextEnrichResult,
   RouteEvent, RouteResult,
   InputEvent, InputResult,
   CommandDefinition,
 } from './extension-types.js';
-import type { Label } from './types.js';
+import type { Label, Skill, Identity } from './types.js';
 
 /**
- * v6 Extension Context — passed as second argument to every event handler.
+ * v7 Extension Context — passed as second argument to every event handler.
  * Extends the base ExtensionContext with labels and optional agent capabilities.
  */
 export interface ExtensionContextV6 extends ExtensionContext {
@@ -39,8 +36,6 @@ export interface ExtensionContextV6 extends ExtensionContext {
 export interface ExtensionAPI {
   // ── Event subscription ──
 
-  /** Resource discovery: extensions declare resources and contribute labels */
-  on(event: 'resources_discover', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<ResourcesDiscoverResult | void>): void;
   /** Label extraction: extensions can add custom labels (chain-transform) */
   on(event: 'label_extract', handler: (e: LabelExtractEvent, ctx: ExtensionContextV6) => Promise<Label[] | void>): void;
   /** Context enrichment: extensions return sections for context injection */
@@ -58,28 +53,28 @@ export interface ExtensionAPI {
 
   on(event: 'session_start', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<void>): void;
   on(event: 'session_end', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<void>): void;
+  on(event: 'session_compact', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<void>): void;
   on(event: 'agent_start', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<void>): void;
   on(event: 'agent_end', handler: (e: AgentEndEvent, ctx: ExtensionContextV6) => Promise<void>): void;
   on(event: 'turn_start', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<void>): void;
   on(event: 'turn_end', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<void>): void;
 
-  // ── Legacy events (kept for transition) ──
-
-  /** @deprecated Use context_enrich instead */
-  on(event: 'context_inject', handler: (e: ContextInjectEvent, ctx: ExtensionContextV6) => Promise<ContextInjectResult | void>): void;
-  /** @deprecated Use context_enrich instead */
-  on(event: 'context_modify', handler: (e: ContextModifyEvent, ctx: ExtensionContextV6) => Promise<ContextModifyResult | void>): void;
-
   // ── Catch-all for custom/Pi-specific events ──
 
   on(event: string, handler: (e: any, ctx: ExtensionContextV6) => Promise<any>): void;
 
-  // ── Capability registration ──
+  // ── Resource registration ──
 
   /** Register a tool that the agent can invoke */
   registerTool(tool: ToolDefinition): void;
   /** Register a command (slash command, etc.) */
   registerCommand(command: CommandDefinition): void;
+  /** Register a skill for context enrichment and discovery */
+  registerSkill(skill: Skill): void;
+  /** Register an identity document */
+  registerIdentity(identity: Identity): void;
+  /** Contribute labels to the global vocabulary (for label matching) */
+  contributeLabels(labels: string[]): void;
 
   // ── Inter-extension communication ──