@dot-ai/adapter-openclaw 0.5.2 → 0.7.0

package/src/__tests__/plugin-integration.test.ts

@@ -0,0 +1,233 @@
+import { describe, it, expect } from 'vitest';
+import { DotAiRuntime, EventBus, ADAPTER_CAPABILITIES } from '@dot-ai/core';
+
+// ── Mock OpenClaw Plugin API ──
+
+interface CapturedHook {
+  event: string;
+  handler: (...args: unknown[]) => unknown;
+  options?: { priority?: number };
+}
+
+interface CapturedService {
+  id: string;
+  start: (ctx: { logger: { info: (msg: string) => void } }) => void;
+  stop: (ctx: { logger: { info: (msg: string) => void } }) => void;
+}
+
+interface CapturedTool {
+  factory?: (ctx: Record<string, unknown>) => unknown;
+  opts?: { name?: string; names?: string[] };
+}
+
+function createMockOpenClawApi() {
+  const logs: string[] = [];
+  const hooks: CapturedHook[] = [];
+  const services: CapturedService[] = [];
+  const tools: CapturedTool[] = [];
+
+  const api = {
+    logger: {
+      info: (msg: string) => logs.push(msg),
+      debug: (msg: string) => logs.push(`[debug] ${msg}`),
+    },
+    pluginConfig: undefined as Record<string, unknown> | undefined,
+    on(
+      event: string,
+      handler: (...args: unknown[]) => unknown,
+      options?: { priority?: number },
+    ) {
+      hooks.push({ event, handler, options });
+    },
+    registerService(service: CapturedService) {
+      services.push(service);
+    },
+    registerTool(factory: (ctx: Record<string, unknown>) => unknown, opts?: { name?: string; names?: string[] }) {
+      tools.push({ factory, opts });
+    },
+  };
+
+  return { api, logs, hooks, services, tools };
+}
+
+// ── Tests ──
+
+describe('OpenClaw Plugin Integration', () => {
+  describe('plugin.register() structure', () => {
+    it('registers before_agent_start hook with priority 10', async () => {
+      const { api, hooks } = createMockOpenClawApi();
+
+      const { default: plugin } = await import('../index.js');
+      plugin.register(api as never);
+
+      const beforeStart = hooks.find(h => h.event === 'before_agent_start');
+      expect(beforeStart).toBeDefined();
+      expect(beforeStart!.options?.priority).toBe(10);
+    });
+
+    it('registers after_agent_end hook', async () => {
+      const { api, hooks } = createMockOpenClawApi();
+      const { default: plugin } = await import('../index.js');
+      plugin.register(api as never);
+
+      const afterEnd = hooks.find(h => h.event === 'after_agent_end');
+      expect(afterEnd).toBeDefined();
+    });
+
+    it('registers dot-ai service', async () => {
+      const { api, services } = createMockOpenClawApi();
+      const { default: plugin } = await import('../index.js');
+      plugin.register(api as never);
+
+      const svc = services.find(s => s.id === 'dot-ai');
+      expect(svc).toBeDefined();
+    });
+
+    it('registers tool factory for capabilities', async () => {
+      const { api, tools } = createMockOpenClawApi();
+      const { default: plugin } = await import('../index.js');
+      plugin.register(api as never);
+
+      expect(tools.length).toBe(1);
+      expect(tools[0].opts?.names).toContain('memory_recall');
+      expect(tools[0].opts?.names).toContain('memory_store');
+      expect(tools[0].opts?.names).toContain('task_list');
+    });
+
+    it('logs plugin version v6', async () => {
+      const { api, logs } = createMockOpenClawApi();
+      const { default: plugin } = await import('../index.js');
+      plugin.register(api as never);
+
+      expect(logs.some(l => l.includes('v6'))).toBe(true);
+    });
+
+    it('has correct plugin metadata', async () => {
+      const { default: plugin } = await import('../index.js');
+      expect(plugin.id).toBe('dot-ai');
+      expect(plugin.version).toBe('6.0.0');
+      expect(plugin.kind).toBe('memory');
+    });
+  });
+
+  describe('before_agent_start → boot → processPrompt', () => {
+    it('skips sub-agent sessions', async () => {
+      const { api, hooks, logs } = createMockOpenClawApi();
+      const { default: plugin } = await import('../index.js');
+      plugin.register(api as never);
+
+      const beforeStart = hooks.find(h => h.event === 'before_agent_start')!;
+      const result = await beforeStart.handler(
+        {},
+        { workspaceDir: '/tmp/test', sessionKey: 'session:subagent:1', prompt: 'hello' },
+      );
+
+      expect(result).toBeUndefined();
+      expect(logs.some(l => l.includes('Sub-agent'))).toBe(true);
+    });
+
+    it('skips cron sessions', async () => {
+      const { api, hooks, logs } = createMockOpenClawApi();
+      const { default: plugin } = await import('../index.js');
+      plugin.register(api as never);
+
+      const beforeStart = hooks.find(h => h.event === 'before_agent_start')!;
+      const result = await beforeStart.handler(
+        {},
+        { workspaceDir: '/tmp/test', sessionKey: 'session:cron:cleanup', prompt: 'cleanup' },
+      );
+
+      expect(result).toBeUndefined();
+      expect(logs.some(l => l.includes('Sub-agent') || l.includes('cron'))).toBe(true);
+    });
+
+    it('skips when no workspaceDir', async () => {
+      const { api, hooks, logs } = createMockOpenClawApi();
+      const { default: plugin } = await import('../index.js');
+      plugin.register(api as never);
+
+      const beforeStart = hooks.find(h => h.event === 'before_agent_start')!;
+      const result = await beforeStart.handler(
+        {},
+        { prompt: 'hello' },
+      );
+
+      expect(result).toBeUndefined();
+      expect(logs.some(l => l.includes('No workspaceDir'))).toBe(true);
+    });
+  });
+
+  describe('DotAiRuntime lifecycle (v6 extension-only)', () => {
+    it('boots and processes prompt', async () => {
+      const runtime = new DotAiRuntime({
+        workspaceRoot: '/tmp/nonexistent',
+        skipIdentities: true,
+      });
+      await runtime.boot();
+      expect(runtime.isBooted).toBe(true);
+
+      const { formatted } = await runtime.processPrompt('hello world');
+      expect(formatted).toBeDefined();
+    });
+
+    it('diagnostics show extension info', async () => {
+      const runtime = new DotAiRuntime({
+        workspaceRoot: '/tmp/nonexistent',
+      });
+      await runtime.boot();
+
+      const diag = runtime.diagnostics;
+      expect(diag.extensions).toEqual([]);
+      expect(diag.capabilityCount).toBe(0);
+    });
+
+    it('learn fires agent_end without throwing', async () => {
+      const runtime = new DotAiRuntime({
+        workspaceRoot: '/tmp/nonexistent',
+      });
+      await runtime.boot();
+      await runtime.learn('test response');
+    });
+  });
+
+  describe('OpenClaw adapter capability matrix', () => {
+    it('OpenClaw supports context_inject, agent_end, session_start', () => {
+      const supported = ADAPTER_CAPABILITIES['openclaw'];
+      expect(supported.has('context_inject')).toBe(true);
+      expect(supported.has('agent_end')).toBe(true);
+      expect(supported.has('session_start')).toBe(true);
+    });
+
+    it('OpenClaw does NOT support tool_call, tool_result, context_modify', () => {
+      const supported = ADAPTER_CAPABILITIES['openclaw'];
+      expect(supported.has('tool_call')).toBe(false);
+      expect(supported.has('tool_result')).toBe(false);
+      expect(supported.has('context_modify')).toBe(false);
+      expect(supported.has('turn_start')).toBe(false);
+      expect(supported.has('turn_end')).toBe(false);
+    });
+  });
+
+  describe('EventBus inter-extension communication', () => {
+    it('extensions can communicate via EventBus', async () => {
+      const eventBus = new EventBus();
+      const received: unknown[] = [];
+
+      eventBus.on('custom:auth-fix', (data: unknown) => {
+        received.push(data);
+      });
+
+      eventBus.emit('custom:auth-fix', { file: 'auth.ts', action: 'refactored' });
+
+      expect(received).toHaveLength(1);
+      expect(received[0]).toEqual({ file: 'auth.ts', action: 'refactored' });
+    });
+
+    it('EventBus errors dont propagate', () => {
+      const eventBus = new EventBus();
+      eventBus.on('test', () => { throw new Error('boom'); });
+
+      expect(() => eventBus.emit('test')).not.toThrow();
+    });
+  });
+});

package/src/index.ts

@@ -1,23 +1,11 @@
 /**
- * dot-ai OpenClaw plugin v4
- *
- * Hooks into before_agent_start to run the full dot-ai pipeline:
- * loadConfig → registerDefaults → createProviders → boot → enrich → formatContext
+ * dot-ai OpenClaw plugin v6
  *
+ * Hooks into before_agent_start to run the full dot-ai pipeline via DotAiRuntime.
+ * Uses the v6 extension-based pipeline — no providers required.
  * Returns enriched context as prependContext for the agent.
  */
-import {
-  loadConfig,
-  registerDefaults,
-  registerProvider,
-  createProviders,
-  boot,
-  enrich,
-  injectRoot,
-  formatContext,
-  type Providers,
-  type BootCache,
-} from '@dot-ai/core';
+import { DotAiRuntime } from '@dot-ai/core';
 
 // Inline OpenClaw plugin API types
 interface OpenClawLogger {
@@ -41,67 +29,59 @@ interface OpenClawPluginApi {
     start(ctx: { logger: OpenClawLogger }): void;
     stop(ctx: { logger: OpenClawLogger }): void;
   }): void;
+  registerTool(tool: OpenClawTool | OpenClawToolFactory, opts?: { name?: string; names?: string[] }): void;
 }
 
-/**
- * Load custom providers declared in pluginConfig.
- * Workspaces declare custom providers via openclaw.json:
- *   plugins.entries.dot-ai.config.customProviders: [
- *     { type: "cockpit", module: "/abs/path/to/provider.ts" }
- *   ]
- */
-async function loadCustomProviders(
-  config: Record<string, unknown>,
-  logger: OpenClawLogger,
-): Promise<void> {
-  const providers = config.customProviders;
-  if (!Array.isArray(providers)) return;
-
-  for (const entry of providers) {
-    if (!entry || typeof entry !== 'object' || !('type' in entry) || !('module' in entry)) continue;
-
-    const { type, module: modulePath } = entry as { type: string; module: string };
-    try {
-      const mod = await import(modulePath);
-      // Find the exported provider class or factory
-      for (const [name, exported] of Object.entries(mod)) {
-        if (typeof exported === 'function') {
-          if (name.endsWith('Provider')) {
-            const ProviderClass = exported as new (opts: Record<string, unknown>) => unknown;
-            registerProvider(`@custom/${type}`, (opts) => new ProviderClass(opts));
-            logger.info(`[dot-ai] Registered custom provider: ${type} (${name})`);
-            break;
-          }
-        }
-      }
-    } catch (err) {
-      logger.info(`[dot-ai] Failed to load custom provider "${type}" from ${modulePath}: ${err}`);
-    }
-  }
+interface OpenClawToolResult {
+  content: Array<{ type: string; text: string }>;
+  details?: Record<string, unknown>;
 }
 
+interface OpenClawTool {
+  name: string;
+  label: string;
+  description: string;
+  parameters: Record<string, unknown>;
+  execute(toolCallId: string, params: Record<string, unknown>): Promise<OpenClawToolResult>;
+}
+
+type OpenClawToolFactory = (ctx: Record<string, unknown>) => OpenClawTool | OpenClawTool[] | null;
+
 // Session-level cache
-let cachedProviders: Providers | null = null;
-let cachedBoot: BootCache | null = null;
+let cachedRuntime: DotAiRuntime | null = null;
 let cachedWorkspace: string | null = null;
 
 const plugin = {
   id: 'dot-ai',
   name: 'dot-ai — Universal AI Workspace Convention',
-  version: '0.4.0',
+  version: '6.0.0',
   description: 'Deterministic context enrichment for OpenClaw agents',
+  kind: 'memory' as const,
 
   register(api: OpenClawPluginApi) {
-    api.logger.info('[dot-ai] Plugin loaded (v4)');
-
-    // Load custom providers if configured — capture the promise so before_agent_start can await it
-    let providerPromise: Promise<void> = Promise.resolve();
-    if (api.pluginConfig) {
-      providerPromise = loadCustomProviders(api.pluginConfig, api.logger);
-    }
-
-    // Register default file-based providers
-    registerDefaults();
+    api.logger.info('[dot-ai] Plugin loaded (v6)');
+
+    // Register tools from core capabilities (delegates to extensions)
+    api.registerTool(
+      (_ctx: Record<string, unknown>) => {
+        if (!cachedRuntime?.isBooted) return null;
+        const capabilities = cachedRuntime.capabilities;
+        return capabilities.map((cap): OpenClawTool => ({
+          name: cap.name,
+          label: cap.name.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
+          description: cap.description,
+          parameters: cap.parameters,
+          async execute(_toolCallId: string, params: Record<string, unknown>): Promise<OpenClawToolResult> {
+            const result = await cap.execute(params);
+            return {
+              content: [{ type: 'text', text: result.text }],
+              ...(result.details && { details: result.details }),
+            };
+          },
+        }));
+      },
+      { names: ['memory_recall', 'memory_store', 'task_list', 'task_create', 'task_update'] },
+    );
 
     // Hook: before_agent_start — run the full pipeline
     api.on(
@@ -110,16 +90,12 @@ const plugin = {
         _event: unknown,
         ctx: { workspaceDir?: string; sessionKey?: string; prompt?: string },
       ) => {
-        // Ensure custom providers are registered before proceeding
-        await providerPromise;
-
         const workspaceDir = ctx.workspaceDir;
         if (!workspaceDir) {
           api.logger.info('[dot-ai] No workspaceDir, skipping');
           return;
         }
 
-        // Skip sub-agent/cron sessions
         const isSubagent = ctx.sessionKey?.includes(':subagent:') || ctx.sessionKey?.includes(':cron:');
         if (isSubagent) {
           api.logger.debug?.('[dot-ai] Sub-agent/cron session, skipping');
@@ -127,33 +103,25 @@ const plugin = {
         }
 
         try {
-          // Boot once per workspace (cache across prompts in same session)
-          if (!cachedProviders || cachedWorkspace !== workspaceDir) {
-            const rawConfig = await loadConfig(workspaceDir);
-
-            // Inject workspaceDir into all provider options
-            const config = injectRoot(rawConfig, workspaceDir);
-            cachedProviders = await createProviders(config);
-            cachedBoot = await boot(cachedProviders);
+          if (!cachedRuntime || cachedWorkspace !== workspaceDir) {
+            cachedRuntime = new DotAiRuntime({ workspaceRoot: workspaceDir });
+            await cachedRuntime.boot();
             cachedWorkspace = workspaceDir;
-            api.logger.info(`[dot-ai] Booted: ${cachedBoot.identities.length} identities, ${cachedBoot.vocabulary.length} vocabulary, ${cachedBoot.skills.length} skills`);
-          }
-
-          // Enrich the prompt
-          const prompt = ctx.prompt ?? '';
-          const enriched = await enrich(prompt, cachedProviders, cachedBoot!);
+            api.logger.info('[dot-ai] Runtime booted (v6)');
 
-          // Load skill content for matched skills
-          for (const skill of enriched.skills) {
-            if (!skill.content && skill.name) {
-              skill.content = await cachedProviders.skills.load(skill.name) ?? undefined;
+            // Log extension diagnostics
+            const diag = cachedRuntime.diagnostics;
+            api.logger.info(`[dot-ai] extensions=${diag.extensions.length}, capabilities=${diag.capabilityCount}`);
+            if (diag.vocabularySize !== undefined) {
+              api.logger.info(`[dot-ai] Vocabulary size: ${diag.vocabularySize}`);
             }
           }
 
-          // Format and inject
-          const formatted = formatContext(enriched);
+          const prompt = ctx.prompt ?? '';
+          const { formatted, enriched } = await cachedRuntime.processPrompt(prompt);
+
           if (formatted) {
-            api.logger.info(`[dot-ai] Injected: ${enriched.identities.length} identities, ${enriched.memories.length} memories, ${enriched.skills.length} skills`);
+            api.logger.info(`[dot-ai] Injected: ${enriched.identities.length} ids, ${enriched.memories.length} mems, ${enriched.skills.length} skills`);
             return { prependContext: formatted };
           }
         } catch (err) {
@@ -164,6 +132,15 @@ const plugin = {
       { priority: 10 },
     );
 
+    // Hook: after_agent_end — feed response back to runtime for learning + extension events
+    api.on('after_agent_end', async (_event, ctx) => {
+      if (!cachedRuntime) return;
+      const response = (ctx as { response?: string }).response ?? '';
+      if (response) {
+        await cachedRuntime.learn(response);
+      }
+    });
+
     // Service registration
     api.registerService({
       id: 'dot-ai',