@tagma/sdk 0.7.1 → 0.7.4

package/src/package-split.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, test } from 'bun:test';
+import { PluginRegistry, InMemoryApprovalGateway } from '@tagma/core';
+import { bunRuntime } from '@tagma/runtime-bun';
+import { createTagma } from './index';
+
+describe('Phase 6 package split', () => {
+  test('sdk composes the core registry and bun runtime packages', () => {
+    const runtime = bunRuntime();
+    const tagma = createTagma({ runtime, builtins: false });
+
+    expect(tagma.registry).toBeInstanceOf(PluginRegistry);
+    expect(typeof runtime.runCommand).toBe('function');
+    expect(new InMemoryApprovalGateway().pending()).toEqual([]);
+  });
+});

package/src/pipeline-runner.test.ts

@@ -1,25 +1,17 @@
 import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { bootstrapBuiltins } from './bootstrap';
 import { PipelineRunner } from './pipeline-runner';
 import { PluginRegistry } from './registry';
-import type { PipelineConfig } from './types';
+import type { PipelineConfig, TagmaRuntime, TaskResult } from './types';
 
 function makeDir(): string {
   return mkdtempSync(join(tmpdir(), 'tagma-pipeline-runner-'));
 }
 
 function bindingsPipeline(dir: string): PipelineConfig {
-  const emit = join(dir, 'emit.js');
-  writeFileSync(
-    emit,
-    'process.stdout.write(JSON.stringify({ city: "Shanghai" }) + "\\n");\n',
-  );
-  const echo = join(dir, 'echo.js');
-  writeFileSync(echo, 'process.stdout.write(process.argv[2] + "\\n");\n');
-
   return {
     name: 'runner-snapshot',
     tracks: [
@@ -30,14 +22,14 @@ function bindingsPipeline(dir: string): PipelineConfig {
           {
             id: 'up',
             name: 'up',
-            command: `node "${emit}"`,
+            command: 'emit-city',
             outputs: { city: { type: 'string' } },
           },
           {
             id: 'down',
             name: 'down',
             depends_on: ['up'],
-            command: `node "${echo}" "{{inputs.city}}"`,
+            command: 'echo-city "{{inputs.city}}"',
             inputs: { city: { from: 't.up.outputs.city', type: 'string', required: true } },
           },
         ],
@@ -46,11 +38,72 @@ function bindingsPipeline(dir: string): PipelineConfig {
   };
 }
 
+function taskResult(stdout: string): TaskResult {
+  return {
+    exitCode: 0,
+    stdout,
+    stderr: '',
+    stdoutPath: null,
+    stderrPath: null,
+    stdoutBytes: stdout.length,
+    stderrBytes: 0,
+    durationMs: 1,
+    sessionId: null,
+    normalizedOutput: null,
+    failureKind: null,
+  };
+}
+
+function fakeRuntime(): TagmaRuntime {
+  return {
+    async runCommand(command) {
+      return command.startsWith('emit-city')
+        ? taskResult('{"city":"Shanghai"}\n')
+        : taskResult('Shanghai\n');
+    },
+    async runSpawn() {
+      throw new Error('runSpawn should not be called');
+    },
+    async ensureDir() {
+      /* no-op */
+    },
+    async fileExists() {
+      return false;
+    },
+    async *watch() {
+      /* no-op */
+    },
+    logStore: {
+      openRunLog({ runId }) {
+        return {
+          path: `mem://${runId}/pipeline.log`,
+          dir: `mem://${runId}`,
+          append() {
+            /* memory sink */
+          },
+          close() {
+            /* memory sink */
+          },
+        };
+      },
+      taskOutputPath({ runId, taskId, stream }) {
+        return `mem://${runId}/${taskId}.${stream}`;
+      },
+      logsDir() {
+        return 'mem://logs';
+      },
+    },
+    now: () => new Date('2026-04-26T00:00:00.000Z'),
+    sleep: () => Promise.resolve(),
+  };
+}
+
 async function run(config: PipelineConfig, dir: string): Promise<PipelineRunner> {
   const registry = new PluginRegistry();
   bootstrapBuiltins(registry);
   const runner = new PipelineRunner(config, dir, {
     registry,
+    runtime: fakeRuntime(),
     skipPluginLoading: true,
   });
 

package/src/plugin-registry.test.ts

@@ -2,10 +2,11 @@ import { describe, expect, test } from 'bun:test';
 import { PluginRegistry } from './registry';
 import { bootstrapBuiltins } from './bootstrap';
 import { runPipeline } from './engine';
-import type { DriverPlugin, TriggerPlugin, PipelineConfig } from './types';
-import { mkdtempSync, rmSync } from 'node:fs';
+import type { DriverPlugin, TriggerPlugin, PipelineConfig, TagmaRuntime, TaskResult } from './types';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import type { TagmaPlugin } from './types';
 
 function makeDriver(name: string, marker: string[]): DriverPlugin {
   return {
@@ -27,6 +28,64 @@ function makeTrigger(name: string, marker: string[]): TriggerPlugin {
   };
 }
 
+function taskResult(stdout = 'ok\n'): TaskResult {
+  return {
+    exitCode: 0,
+    stdout,
+    stderr: '',
+    stdoutPath: null,
+    stderrPath: null,
+    stdoutBytes: stdout.length,
+    stderrBytes: 0,
+    durationMs: 1,
+    sessionId: null,
+    normalizedOutput: null,
+    failureKind: null,
+  };
+}
+
+function fakeRuntime(): TagmaRuntime {
+  return {
+    async runCommand() {
+      return taskResult();
+    },
+    async runSpawn() {
+      return taskResult();
+    },
+    async ensureDir() {
+      /* no-op */
+    },
+    async fileExists() {
+      return false;
+    },
+    async *watch() {
+      /* no-op */
+    },
+    logStore: {
+      openRunLog({ runId }) {
+        return {
+          path: `mem://${runId}/pipeline.log`,
+          dir: `mem://${runId}`,
+          append() {
+            /* memory sink */
+          },
+          close() {
+            /* memory sink */
+          },
+        };
+      },
+      taskOutputPath({ runId, taskId, stream }) {
+        return `mem://${runId}/${taskId}.${stream}`;
+      },
+      logsDir() {
+        return 'mem://logs';
+      },
+    },
+    now: () => new Date('2026-04-26T00:00:00.000Z'),
+    sleep: () => Promise.resolve(),
+  };
+}
+
 describe('PluginRegistry — instance isolation', () => {
   test('two registries do not share drivers registered under the same type', () => {
     const regA = new PluginRegistry();
@@ -100,6 +159,130 @@ describe('PluginRegistry — instance isolation', () => {
   });
 });
 
+describe('PluginRegistry — capability plugins', () => {
+  test('registerTagmaPlugin registers multiple capabilities from one package', () => {
+    const reg = new PluginRegistry();
+    const driver = makeDriver('cap-driver', []);
+    const trigger = makeTrigger('cap-trigger', []);
+    const plugin: TagmaPlugin = {
+      name: 'tagma-plugin-multi',
+      capabilities: {
+        drivers: { cap_driver: driver },
+        triggers: { cap_trigger: trigger },
+      },
+    };
+
+    expect(reg.registerTagmaPlugin(plugin)).toEqual([
+      { category: 'drivers', type: 'cap_driver', result: 'registered' },
+      { category: 'triggers', type: 'cap_trigger', result: 'registered' },
+    ]);
+    expect(reg.getHandler<DriverPlugin>('drivers', 'cap_driver')).toBe(driver);
+    expect(reg.getHandler<TriggerPlugin>('triggers', 'cap_trigger')).toBe(trigger);
+  });
+
+  test('registerTagmaPlugin keeps replacement warnings from the registry path', () => {
+    const reg = new PluginRegistry();
+    const originalWarn = console.warn;
+    const warnings: string[] = [];
+    console.warn = (message?: unknown) => {
+      warnings.push(String(message));
+    };
+    try {
+      reg.registerPlugin('drivers', 'mock', makeDriver('first', []));
+      const result = reg.registerTagmaPlugin({
+        name: 'tagma-plugin-replacement',
+        capabilities: {
+          drivers: { mock: makeDriver('second', []) },
+        },
+      });
+
+      expect(result).toEqual([{ category: 'drivers', type: 'mock', result: 'replaced' }]);
+      expect(warnings).toContain(
+        '[tagma-sdk] registerPlugin: replaced existing drivers/mock - check for duplicate plugin packages claiming the same type.',
+      );
+    } finally {
+      console.warn = originalWarn;
+    }
+  });
+
+  test('loadPlugins accepts capability plugin default exports', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'tagma-capability-plugin-'));
+    const pluginDir = join(dir, 'node_modules', 'tagma-plugin-capability');
+    mkdirSync(pluginDir, { recursive: true });
+    writeFileSync(
+      join(pluginDir, 'package.json'),
+      JSON.stringify({ name: 'tagma-plugin-capability', version: '1.0.0', type: 'module', main: './index.js' }),
+      'utf-8',
+    );
+    writeFileSync(
+      join(pluginDir, 'index.js'),
+      [
+        'const driver = {',
+        "  name: 'cap-driver',",
+        '  capabilities: { sessionResume: false, systemPrompt: false, outputFormat: false },',
+        "  async buildCommand() { return { args: ['echo', 'cap'] }; },",
+        '};',
+        'const trigger = {',
+        "  name: 'cap-trigger',",
+        '  async watch() {}',
+        '};',
+        'export default {',
+        "  name: 'tagma-plugin-capability',",
+        '  capabilities: {',
+        '    drivers: { cap_driver: driver },',
+        '    triggers: { cap_trigger: trigger },',
+        '  },',
+        '};',
+        '',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    try {
+      const reg = new PluginRegistry();
+      await reg.loadPlugins(['tagma-plugin-capability'], dir);
+      expect(reg.hasHandler('drivers', 'cap_driver')).toBe(true);
+      expect(reg.hasHandler('triggers', 'cap_trigger')).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test('loadPlugins rejects legacy plugin module exports', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'tagma-legacy-plugin-'));
+    const pluginDir = join(dir, 'node_modules', 'tagma-plugin-legacy');
+    mkdirSync(pluginDir, { recursive: true });
+    writeFileSync(
+      join(pluginDir, 'package.json'),
+      JSON.stringify({ name: 'tagma-plugin-legacy', version: '1.0.0', type: 'module', main: './index.js' }),
+      'utf-8',
+    );
+    writeFileSync(
+      join(pluginDir, 'index.js'),
+      [
+        "export const pluginCategory = 'drivers';",
+        "export const pluginType = 'legacy';",
+        'export default {',
+        "  name: 'legacy',",
+        '  capabilities: { sessionResume: false, systemPrompt: false, outputFormat: false },',
+        "  async buildCommand() { return { args: ['echo', 'legacy'] }; },",
+        '};',
+        '',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    try {
+      const reg = new PluginRegistry();
+      await expect(reg.loadPlugins(['tagma-plugin-legacy'], dir)).rejects.toThrow(
+        /must default-export a TagmaPlugin/,
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
 describe('PluginRegistry — validation', () => {
   test('rejects unknown category', () => {
     const reg = new PluginRegistry();
@@ -153,6 +336,18 @@ describe('PluginRegistry — validation', () => {
       /bun add @tagma\/middleware-audit/,
     );
   });
+
+  test('rejects middleware without enhanceDoc', () => {
+    const reg = new PluginRegistry();
+    expect(() =>
+      reg.registerPlugin('middlewares', 'old', {
+        name: 'old',
+        async enhance(prompt: string) {
+          return prompt;
+        },
+      } as never),
+    ).toThrow(/must export enhanceDoc/);
+  });
 });
 
 describe('runPipeline — options.registry isolation', () => {
@@ -187,8 +382,16 @@ describe('runPipeline — options.registry isolation', () => {
     const tmpB = mkdtempSync(join(tmpdir(), 'tagma-regB-'));
     try {
       const [resA, resB] = await Promise.all([
-        runPipeline(config, tmpA, { registry: regA, skipPluginLoading: true }),
-        runPipeline(config, tmpB, { registry: regB, skipPluginLoading: true }),
+        runPipeline(config, tmpA, {
+          registry: regA,
+          runtime: fakeRuntime(),
+          skipPluginLoading: true,
+        }),
+        runPipeline(config, tmpB, {
+          registry: regB,
+          runtime: fakeRuntime(),
+          skipPluginLoading: true,
+        }),
       ]);
       expect(resA.success).toBe(true);
       expect(resB.success).toBe(true);

package/src/plugins.ts

@@ -4,15 +4,18 @@ export {
   isValidPluginName,
   PLUGIN_NAME_RE,
   readPluginManifest,
-} from './registry';
-export type { RegisterResult } from './registry';
+} from '@tagma/core';
+export type { RegisteredCapability, RegisterResult } from '@tagma/core';
 export type {
+  CapabilityHandler,
   PluginCategory,
+  PluginCapabilities,
   PluginModule,
   PluginManifest,
+  PluginSetupContext,
+  TagmaPlugin,
   DriverPlugin,
   TriggerPlugin,
   CompletionPlugin,
   MiddlewarePlugin,
 } from './types';
-