apcore-js 0.1.1 → 0.1.2

package/tests/schema/test-exporter.test.ts

@@ -0,0 +1,171 @@
+/**
+ * Tests for schema/exporter.ts — SchemaExporter profile exports.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { SchemaExporter } from '../../src/schema/exporter.js';
+import { ExportProfile } from '../../src/schema/types.js';
+import type { SchemaDefinition } from '../../src/schema/types.js';
+import type { ModuleAnnotations, ModuleExample } from '../../src/module.js';
+
+function makeSchemaDef(overrides?: Partial<SchemaDefinition>): SchemaDefinition {
+  return {
+    moduleId: 'test.module',
+    description: 'A test module',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Name', 'x-llm-description': 'LLM Name' },
+      },
+      required: ['name'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        result: { type: 'string' },
+      },
+    },
+    definitions: {},
+    version: '1.0.0',
+    ...overrides,
+  };
+}
+
+describe('SchemaExporter', () => {
+  const exporter = new SchemaExporter();
+
+  describe('exportGeneric', () => {
+    it('returns module_id, description, input/output schemas, and definitions', () => {
+      const sd = makeSchemaDef();
+      const result = exporter.exportGeneric(sd);
+      expect(result['module_id']).toBe('test.module');
+      expect(result['description']).toBe('A test module');
+      expect(result['input_schema']).toEqual(sd.inputSchema);
+      expect(result['output_schema']).toEqual(sd.outputSchema);
+      expect(result['definitions']).toEqual({});
+    });
+  });
+
+  describe('exportMcp', () => {
+    it('returns MCP tool format with annotations', () => {
+      const sd = makeSchemaDef();
+      const annotations: ModuleAnnotations = {
+        readonly: true,
+        destructive: false,
+        idempotent: true,
+        requiresApproval: false,
+        openWorld: false,
+      };
+      const result = exporter.exportMcp(sd, annotations, 'MyTool');
+      expect(result['name']).toBe('MyTool');
+      expect(result['description']).toBe('A test module');
+      expect(result['inputSchema']).toEqual(sd.inputSchema);
+      const annots = result['annotations'] as Record<string, unknown>;
+      expect(annots['readOnlyHint']).toBe(true);
+      expect(annots['destructiveHint']).toBe(false);
+      expect(annots['idempotentHint']).toBe(true);
+      expect(annots['openWorldHint']).toBe(false);
+    });
+
+    it('falls back to moduleId when name is null', () => {
+      const sd = makeSchemaDef();
+      const result = exporter.exportMcp(sd, null, null);
+      expect(result['name']).toBe('test.module');
+    });
+
+    it('uses default annotation values when annotations is null', () => {
+      const sd = makeSchemaDef();
+      const result = exporter.exportMcp(sd, null);
+      const annots = result['annotations'] as Record<string, unknown>;
+      expect(annots['readOnlyHint']).toBe(false);
+      expect(annots['destructiveHint']).toBe(false);
+      expect(annots['idempotentHint']).toBe(false);
+      expect(annots['openWorldHint']).toBe(true);
+    });
+  });
+
+  describe('exportOpenai', () => {
+    it('returns OpenAI function calling format with strict schema', () => {
+      const sd = makeSchemaDef();
+      const result = exporter.exportOpenai(sd);
+      expect(result['type']).toBe('function');
+      const fn = result['function'] as Record<string, unknown>;
+      expect(fn['name']).toBe('test_module');
+      expect(fn['description']).toBe('A test module');
+      expect(fn['strict']).toBe(true);
+      const params = fn['parameters'] as Record<string, unknown>;
+      expect(params['additionalProperties']).toBe(false);
+    });
+
+    it('applies x-llm-description to properties', () => {
+      const sd = makeSchemaDef();
+      const result = exporter.exportOpenai(sd);
+      const fn = result['function'] as Record<string, unknown>;
+      const params = fn['parameters'] as Record<string, unknown>;
+      const props = params['properties'] as Record<string, Record<string, unknown>>;
+      expect(props['name']['description']).toBe('LLM Name');
+    });
+  });
+
+  describe('exportAnthropic', () => {
+    it('returns Anthropic tool format', () => {
+      const sd = makeSchemaDef();
+      const result = exporter.exportAnthropic(sd);
+      expect(result['name']).toBe('test_module');
+      expect(result['description']).toBe('A test module');
+      expect(result['input_schema']).toBeDefined();
+    });
+
+    it('includes input_examples when examples are provided', () => {
+      const sd = makeSchemaDef();
+      const examples: ModuleExample[] = [
+        { title: 'Ex1', inputs: { name: 'Alice' }, output: { result: 'ok' } },
+      ];
+      const result = exporter.exportAnthropic(sd, examples);
+      const inputExamples = result['input_examples'] as Array<Record<string, unknown>>;
+      expect(inputExamples).toHaveLength(1);
+      expect(inputExamples[0]).toEqual({ name: 'Alice' });
+    });
+
+    it('omits input_examples when no examples', () => {
+      const sd = makeSchemaDef();
+      const result = exporter.exportAnthropic(sd, []);
+      expect(result['input_examples']).toBeUndefined();
+    });
+
+    it('strips x- extensions from schema', () => {
+      const sd = makeSchemaDef();
+      const result = exporter.exportAnthropic(sd);
+      const schema = result['input_schema'] as Record<string, unknown>;
+      const props = schema['properties'] as Record<string, Record<string, unknown>>;
+      expect(props['name']['x-llm-description']).toBeUndefined();
+    });
+  });
+
+  describe('export dispatch', () => {
+    it('dispatches to MCP profile', () => {
+      const sd = makeSchemaDef();
+      const result = exporter.export(sd, ExportProfile.MCP);
+      expect(result['name']).toBe('test.module');
+      expect(result['annotations']).toBeDefined();
+    });
+
+    it('dispatches to OpenAI profile', () => {
+      const sd = makeSchemaDef();
+      const result = exporter.export(sd, ExportProfile.OpenAI);
+      expect(result['type']).toBe('function');
+    });
+
+    it('dispatches to Anthropic profile', () => {
+      const sd = makeSchemaDef();
+      const result = exporter.export(sd, ExportProfile.Anthropic);
+      expect(result['input_schema']).toBeDefined();
+    });
+
+    it('dispatches to Generic profile', () => {
+      const sd = makeSchemaDef();
+      const result = exporter.export(sd, ExportProfile.Generic);
+      expect(result['module_id']).toBe('test.module');
+    });
+  });
+});

package/tests/test-logging-middleware.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Tests for middleware/logging.ts — LoggingMiddleware.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { LoggingMiddleware } from '../src/middleware/logging.js';
+import type { Logger } from '../src/middleware/logging.js';
+import { Context } from '../src/context.js';
+
+function makeContext(moduleId: string = 'test.mod'): Context {
+  const ctx = Context.create(null);
+  return ctx.child(moduleId);
+}
+
+function makeLogger(): Logger & { infoCalls: Array<[string, unknown]>; errorCalls: Array<[string, unknown]> } {
+  const logger = {
+    infoCalls: [] as Array<[string, unknown]>,
+    errorCalls: [] as Array<[string, unknown]>,
+    info(message: string, extra?: Record<string, unknown>) {
+      logger.infoCalls.push([message, extra]);
+    },
+    error(message: string, extra?: Record<string, unknown>) {
+      logger.errorCalls.push([message, extra]);
+    },
+  };
+  return logger;
+}
+
+describe('LoggingMiddleware', () => {
+  describe('before', () => {
+    it('logs module start with inputs when logInputs is true', () => {
+      const logger = makeLogger();
+      const mw = new LoggingMiddleware({ logger, logInputs: true });
+      const ctx = makeContext('my.module');
+      const result = mw.before('my.module', { key: 'val' }, ctx);
+      expect(result).toBeNull();
+      expect(logger.infoCalls).toHaveLength(1);
+      expect(logger.infoCalls[0][0]).toContain('START my.module');
+    });
+
+    it('does not log when logInputs is false', () => {
+      const logger = makeLogger();
+      const mw = new LoggingMiddleware({ logger, logInputs: false });
+      const ctx = makeContext();
+      mw.before('mod', { key: 'val' }, ctx);
+      expect(logger.infoCalls).toHaveLength(0);
+    });
+
+    it('stores start time in context data', () => {
+      const logger = makeLogger();
+      const mw = new LoggingMiddleware({ logger });
+      const ctx = makeContext();
+      mw.before('mod', {}, ctx);
+      expect(typeof ctx.data['_logging_mw_start']).toBe('number');
+    });
+
+    it('uses redacted inputs when available', () => {
+      const logger = makeLogger();
+      const mw = new LoggingMiddleware({ logger, logInputs: true });
+      const ctx = makeContext();
+      ctx.redactedInputs = { key: '***REDACTED***' };
+      mw.before('mod', { key: 'secret' }, ctx);
+      const extra = logger.infoCalls[0][1] as Record<string, unknown>;
+      expect(extra['inputs']).toEqual({ key: '***REDACTED***' });
+    });
+  });
+
+  describe('after', () => {
+    it('logs module end with duration when logOutputs is true', () => {
+      const logger = makeLogger();
+      const mw = new LoggingMiddleware({ logger, logOutputs: true });
+      const ctx = makeContext('my.module');
+      ctx.data['_logging_mw_start'] = performance.now() - 100;
+      const result = mw.after('my.module', {}, { result: 'ok' }, ctx);
+      expect(result).toBeNull();
+      expect(logger.infoCalls).toHaveLength(1);
+      expect(logger.infoCalls[0][0]).toContain('END my.module');
+      expect(logger.infoCalls[0][0]).toMatch(/\d+\.\d+ms/);
+    });
+
+    it('does not log when logOutputs is false', () => {
+      const logger = makeLogger();
+      const mw = new LoggingMiddleware({ logger, logOutputs: false });
+      const ctx = makeContext();
+      mw.after('mod', {}, { result: 'ok' }, ctx);
+      expect(logger.infoCalls).toHaveLength(0);
+    });
+
+    it('handles missing start time gracefully', () => {
+      const logger = makeLogger();
+      const mw = new LoggingMiddleware({ logger, logOutputs: true });
+      const ctx = makeContext();
+      mw.after('mod', {}, { result: 'ok' }, ctx);
+      expect(logger.infoCalls).toHaveLength(1);
+    });
+  });
+
+  describe('onError', () => {
+    it('logs error with redacted inputs when logErrors is true', () => {
+      const logger = makeLogger();
+      const mw = new LoggingMiddleware({ logger, logErrors: true });
+      const ctx = makeContext('my.module');
+      ctx.redactedInputs = { safe: 'data' };
+      const error = new Error('something broke');
+      const result = mw.onError('my.module', { secret: 'val' }, error, ctx);
+      expect(result).toBeNull();
+      expect(logger.errorCalls).toHaveLength(1);
+      expect(logger.errorCalls[0][0]).toContain('ERROR my.module');
+      const extra = logger.errorCalls[0][1] as Record<string, unknown>;
+      expect(extra['inputs']).toEqual({ safe: 'data' });
+    });
+
+    it('does not log when logErrors is false', () => {
+      const logger = makeLogger();
+      const mw = new LoggingMiddleware({ logger, logErrors: false });
+      const ctx = makeContext();
+      mw.onError('mod', {}, new Error('fail'), ctx);
+      expect(logger.errorCalls).toHaveLength(0);
+    });
+
+    it('uses raw inputs when redactedInputs is null', () => {
+      const logger = makeLogger();
+      const mw = new LoggingMiddleware({ logger, logErrors: true });
+      const ctx = makeContext();
+      mw.onError('mod', { raw: 'data' }, new Error('fail'), ctx);
+      const extra = logger.errorCalls[0][1] as Record<string, unknown>;
+      expect(extra['inputs']).toEqual({ raw: 'data' });
+    });
+  });
+
+  describe('defaults', () => {
+    it('uses default logger when none provided', () => {
+      const mw = new LoggingMiddleware();
+      const ctx = makeContext();
+      // Should not throw
+      expect(() => mw.before('mod', {}, ctx)).not.toThrow();
+    });
+
+    it('enables all logging by default', () => {
+      const logger = makeLogger();
+      const mw = new LoggingMiddleware({ logger });
+      const ctx = makeContext();
+      mw.before('mod', {}, ctx);
+      mw.after('mod', {}, { r: 1 }, ctx);
+      mw.onError('mod', {}, new Error('e'), ctx);
+      expect(logger.infoCalls).toHaveLength(2);
+      expect(logger.errorCalls).toHaveLength(1);
+    });
+  });
+});