apcore-js 0.3.0 → 0.4.0

package/tests/registry/test-schema-export.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { Type } from '@sinclair/typebox';
 import { Registry } from '../../src/registry/registry.js';
 import { FunctionModule } from '../../src/decorator.js';
-import { ModuleNotFoundError } from '../../src/errors.js';
+import { InvalidInputError, ModuleNotFoundError } from '../../src/errors.js';
 import {
   getSchema,
   exportSchema,
@@ -218,8 +218,138 @@ describe('exportAllSchemas', () => {
     expect((parsed['strict.a']['input_schema'] as Record<string, unknown>)['additionalProperties']).toBe(false);
   });
 
+  it('applies compact mode to all schemas', () => {
+    const mod = createModule('compact.all');
+    const registry = makeRegistry(['compact.all', mod]);
+
+    const result = exportAllSchemas(registry, 'json', false, true);
+    const parsed = JSON.parse(result);
+    expect(parsed['compact.all']['description']).toBe('A test module.');
+    expect(parsed['compact.all']['examples']).toBeUndefined();
+  });
+
   it('returns empty JSON object for empty registry', () => {
     const registry = new Registry();
     expect(JSON.parse(exportAllSchemas(registry))).toEqual({});
   });
 });
+
+describe('exportSchema with profile', () => {
+  it('exports with mcp profile and returns valid JSON with MCP shape', () => {
+    const mod = createModule('mcp.mod');
+    const registry = makeRegistry(['mcp.mod', mod]);
+
+    const result = exportSchema(registry, 'mcp.mod', 'json', false, false, 'mcp');
+    const parsed = JSON.parse(result);
+    expect(parsed['name']).toBeDefined();
+    expect(parsed['description']).toBeDefined();
+    expect(parsed['inputSchema']).toBeDefined();
+    expect(parsed['annotations']).toBeDefined();
+    expect(parsed['annotations']['readOnlyHint']).toBe(true);
+    expect(parsed['annotations']['destructiveHint']).toBe(false);
+  });
+
+  it('exports with openai profile and returns function tool shape', () => {
+    const mod = createModule('openai.mod');
+    const registry = makeRegistry(['openai.mod', mod]);
+
+    const result = exportSchema(registry, 'openai.mod', 'json', false, false, 'openai');
+    const parsed = JSON.parse(result);
+    expect(parsed['type']).toBe('function');
+    expect(parsed['function']).toBeDefined();
+    expect(parsed['function']['name']).toBe('openai_mod');
+    expect(parsed['function']['description']).toBeDefined();
+    expect(parsed['function']['parameters']).toBeDefined();
+    expect(parsed['function']['strict']).toBe(true);
+  });
+
+  it('exports with anthropic profile and returns tool shape with input_examples', () => {
+    const mod = createModule('anthro.mod');
+    const registry = makeRegistry(['anthro.mod', mod]);
+
+    const result = exportSchema(registry, 'anthro.mod', 'json', false, false, 'anthropic');
+    const parsed = JSON.parse(result);
+    expect(parsed['name']).toBe('anthro_mod');
+    expect(parsed['description']).toBeDefined();
+    expect(parsed['input_schema']).toBeDefined();
+    expect(parsed['input_examples']).toBeDefined();
+    expect((parsed['input_examples'] as unknown[]).length).toBe(1);
+  });
+
+  it('exports with generic profile and returns module_id and schema fields', () => {
+    const mod = createModule('generic.mod');
+    const registry = makeRegistry(['generic.mod', mod]);
+
+    const result = exportSchema(registry, 'generic.mod', 'json', false, false, 'generic');
+    const parsed = JSON.parse(result);
+    expect(parsed['module_id']).toBe('generic.mod');
+    expect(parsed['description']).toBeDefined();
+    expect(parsed['input_schema']).toBeDefined();
+    expect(parsed['output_schema']).toBeDefined();
+    expect(parsed['definitions']).toBeDefined();
+  });
+
+  it('exports with profile using yaml format', () => {
+    const mod = createModule('mcp.yaml');
+    const registry = makeRegistry(['mcp.yaml', mod]);
+
+    const result = exportSchema(registry, 'mcp.yaml', 'yaml', false, false, 'mcp');
+    expect(result).toContain('name:');
+    expect(result).toContain('inputSchema:');
+  });
+
+  it('throws InvalidInputError for an unrecognized profile name', () => {
+    const mod = createModule('bad.profile');
+    const registry = makeRegistry(['bad.profile', mod]);
+
+    expect(() =>
+      exportSchema(registry, 'bad.profile', 'json', false, false, 'not_a_real_profile'),
+    ).toThrow(InvalidInputError);
+  });
+
+  it('includes the invalid profile name in the error message', () => {
+    const mod = createModule('err.profile');
+    const registry = makeRegistry(['err.profile', mod]);
+
+    expect(() =>
+      exportSchema(registry, 'err.profile', 'json', false, false, 'bogus'),
+    ).toThrowError(/bogus/);
+  });
+});
+
+describe('truncateDescription edge cases', () => {
+  it('returns the full string when there is no dot-space or newline', () => {
+    const mod = createModule('no.boundary', {
+      description: 'A simple description with no sentence boundary',
+    });
+    const registry = makeRegistry(['no.boundary', mod]);
+
+    const result = exportSchema(registry, 'no.boundary', 'json', false, true);
+    const parsed = JSON.parse(result);
+    expect(parsed['description']).toBe('A simple description with no sentence boundary');
+  });
+
+  it('truncates at the earlier boundary when both dot-space and newline are present', () => {
+    // newline comes before dot-space: "Line one\nSecond sentence. More text."
+    const mod = createModule('newline.first', {
+      description: 'Line one\nSecond sentence. More text.',
+    });
+    const registry = makeRegistry(['newline.first', mod]);
+
+    const result = exportSchema(registry, 'newline.first', 'json', false, true);
+    const parsed = JSON.parse(result);
+    expect(parsed['description']).toBe('Line one');
+  });
+
+  it('truncates at dot-space when it comes before a newline', () => {
+    // dot-space before newline: "First sentence. Second line\nThird."
+    const mod = createModule('dotspace.first', {
+      description: 'First sentence. Second line\nThird.',
+    });
+    const registry = makeRegistry(['dotspace.first', mod]);
+
+    const result = exportSchema(registry, 'dotspace.first', 'json', false, true);
+    const parsed = JSON.parse(result);
+    expect(parsed['description']).toBe('First sentence.');
+  });
+});

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

@@ -1,7 +1,371 @@
-import { describe, it, expect } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { Type } from '@sinclair/typebox';
 import { Value } from '@sinclair/typebox/value';
-import { jsonSchemaToTypeBox } from '../../src/schema/loader.js';
+import { Config } from '../../src/config.js';
+import { SchemaNotFoundError, SchemaParseError } from '../../src/errors.js';
+import { SchemaLoader, jsonSchemaToTypeBox } from '../../src/schema/loader.js';
+
+describe('SchemaLoader', () => {
+  let tmpDir: string;
+  let schemasDir: string;
+
+  beforeEach(() => {
+    tmpDir = join(tmpdir(), `apcore-test-loader-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    schemasDir = join(tmpDir, 'schemas');
+    mkdirSync(schemasDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function writeSchema(relPath: string, content: string): void {
+    const fullPath = join(schemasDir, relPath);
+    const dir = fullPath.replace(/\/[^/]+$/, '');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(fullPath, content, 'utf-8');
+  }
+
+  function makeConfig(overrides?: Record<string, unknown>): Config {
+    return new Config({
+      schema: { root: schemasDir, strategy: 'yaml_first', ...overrides },
+    });
+  }
+
+  describe('load', () => {
+    it('loads a valid YAML schema file', () => {
+      writeSchema('greeter.schema.yaml', `
+description: A greeter module
+input_schema:
+  type: object
+  properties:
+    name:
+      type: string
+  required:
+    - name
+output_schema:
+  type: object
+  properties:
+    message:
+      type: string
+`);
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      const sd = loader.load('greeter');
+
+      expect(sd.moduleId).toBe('greeter');
+      expect(sd.description).toBe('A greeter module');
+      expect(sd.inputSchema).toEqual({
+        type: 'object',
+        properties: { name: { type: 'string' } },
+        required: ['name'],
+      });
+      expect(sd.version).toBe('1.0.0');
+    });
+
+    it('loads a schema with dot-separated module ID (nested path)', () => {
+      writeSchema('math/add.schema.yaml', `
+description: Add numbers
+input_schema:
+  type: object
+  properties:
+    a:
+      type: number
+output_schema:
+  type: object
+  properties:
+    result:
+      type: number
+`);
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      const sd = loader.load('math.add');
+
+      expect(sd.moduleId).toBe('math.add');
+      expect(sd.description).toBe('Add numbers');
+    });
+
+    it('throws SchemaNotFoundError for non-existent schema', () => {
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      expect(() => loader.load('nonexistent')).toThrow(SchemaNotFoundError);
+    });
+
+    it('throws SchemaParseError for invalid YAML', () => {
+      writeSchema('bad.schema.yaml', '{ invalid yaml:: [');
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      expect(() => loader.load('bad')).toThrow(SchemaParseError);
+    });
+
+    it('throws SchemaParseError for empty file', () => {
+      writeSchema('empty.schema.yaml', '');
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      expect(() => loader.load('empty')).toThrow(SchemaParseError);
+    });
+
+    it('throws SchemaParseError for array YAML', () => {
+      writeSchema('arr.schema.yaml', '- item1\n- item2\n');
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      expect(() => loader.load('arr')).toThrow(SchemaParseError);
+    });
+
+    it('throws SchemaParseError when required field is missing', () => {
+      writeSchema('noinput.schema.yaml', `
+description: Missing input_schema
+output_schema:
+  type: object
+`);
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      expect(() => loader.load('noinput')).toThrow(SchemaParseError);
+      expect(() => loader.load('noinput')).toThrow(/Missing required field/);
+    });
+
+    it('merges definitions and $defs', () => {
+      writeSchema('withdefs.schema.yaml', `
+description: Has definitions
+input_schema:
+  type: object
+output_schema:
+  type: object
+definitions:
+  Foo:
+    type: string
+$defs:
+  Bar:
+    type: integer
+`);
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      const sd = loader.load('withdefs');
+      expect(sd.definitions).toEqual({ Foo: { type: 'string' }, Bar: { type: 'integer' } });
+    });
+
+    it('returns cached result on second call', () => {
+      writeSchema('cached.schema.yaml', `
+description: Cached
+input_schema:
+  type: object
+output_schema:
+  type: object
+`);
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      const first = loader.load('cached');
+      const second = loader.load('cached');
+      expect(first).toBe(second);
+    });
+
+    it('preserves optional fields (version, documentation, errorSchema)', () => {
+      writeSchema('full.schema.yaml', `
+description: Full schema
+version: "2.0.0"
+documentation: "Some docs"
+input_schema:
+  type: object
+output_schema:
+  type: object
+error_schema:
+  type: object
+  properties:
+    code:
+      type: string
+`);
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      const sd = loader.load('full');
+      expect(sd.version).toBe('2.0.0');
+      expect(sd.documentation).toBe('Some docs');
+      expect(sd.errorSchema).toEqual({ type: 'object', properties: { code: { type: 'string' } } });
+    });
+  });
+
+  describe('resolve', () => {
+    it('resolves a schema definition into TypeBox schemas', () => {
+      writeSchema('resolvable.schema.yaml', `
+description: Resolvable
+input_schema:
+  type: object
+  properties:
+    query:
+      type: string
+  required:
+    - query
+output_schema:
+  type: object
+  properties:
+    result:
+      type: string
+`);
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      const sd = loader.load('resolvable');
+      const [inputRs, outputRs] = loader.resolve(sd);
+
+      expect(inputRs.moduleId).toBe('resolvable');
+      expect(inputRs.direction).toBe('input');
+      expect(Value.Check(inputRs.schema, { query: 'hello' })).toBe(true);
+      expect(Value.Check(inputRs.schema, {})).toBe(false);
+
+      expect(outputRs.moduleId).toBe('resolvable');
+      expect(outputRs.direction).toBe('output');
+      expect(Value.Check(outputRs.schema, { result: 'world' })).toBe(true);
+    });
+  });
+
+  describe('getSchema', () => {
+    const validYaml = `
+description: Test module
+input_schema:
+  type: object
+  properties:
+    x:
+      type: string
+  required:
+    - x
+output_schema:
+  type: object
+  properties:
+    y:
+      type: string
+`;
+
+    it('uses yaml_first strategy and finds YAML', () => {
+      writeSchema('mod.schema.yaml', validYaml);
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      const [inputRs, outputRs] = loader.getSchema('mod');
+
+      expect(inputRs.direction).toBe('input');
+      expect(outputRs.direction).toBe('output');
+      expect(Value.Check(inputRs.schema, { x: 'hi' })).toBe(true);
+    });
+
+    it('uses yaml_first strategy and falls back to native when YAML not found', () => {
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      const nativeInput = Type.Object({ a: Type.String() });
+      const nativeOutput = Type.Object({ b: Type.Number() });
+
+      const [inputRs, outputRs] = loader.getSchema('missing', nativeInput, nativeOutput);
+
+      expect(inputRs.direction).toBe('input');
+      expect(inputRs.moduleId).toBe('missing');
+      expect(Value.Check(inputRs.schema, { a: 'test' })).toBe(true);
+      expect(outputRs.direction).toBe('output');
+      expect(Value.Check(outputRs.schema, { b: 42 })).toBe(true);
+    });
+
+    it('uses yaml_first strategy and throws when YAML not found and no native schemas', () => {
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+      expect(() => loader.getSchema('missing')).toThrow(SchemaNotFoundError);
+    });
+
+    it('uses native_first strategy and prefers native when available', () => {
+      writeSchema('native.schema.yaml', validYaml);
+      const config = makeConfig({ strategy: 'native_first' });
+      const loader = new SchemaLoader(config, schemasDir);
+
+      const nativeInput = Type.Object({ custom: Type.Boolean() });
+      const nativeOutput = Type.Object({ out: Type.Boolean() });
+
+      const [inputRs] = loader.getSchema('native', nativeInput, nativeOutput);
+      // Should use native, not YAML
+      expect(Value.Check(inputRs.schema, { custom: true })).toBe(true);
+      expect(Value.Check(inputRs.schema, { x: 'string' })).toBe(false);
+    });
+
+    it('uses native_first strategy and falls back to YAML when no native', () => {
+      writeSchema('fallback.schema.yaml', validYaml);
+      const config = makeConfig({ strategy: 'native_first' });
+      const loader = new SchemaLoader(config, schemasDir);
+
+      const [inputRs] = loader.getSchema('fallback');
+      expect(Value.Check(inputRs.schema, { x: 'hi' })).toBe(true);
+    });
+
+    it('uses yaml_only strategy', () => {
+      writeSchema('yamlonly.schema.yaml', validYaml);
+      const config = makeConfig({ strategy: 'yaml_only' });
+      const loader = new SchemaLoader(config, schemasDir);
+
+      const [inputRs] = loader.getSchema('yamlonly');
+      expect(Value.Check(inputRs.schema, { x: 'hi' })).toBe(true);
+    });
+
+    it('uses yaml_only strategy and throws when YAML not found', () => {
+      const config = makeConfig({ strategy: 'yaml_only' });
+      const loader = new SchemaLoader(config, schemasDir);
+
+      const nativeInput = Type.Object({ a: Type.String() });
+      const nativeOutput = Type.Object({ b: Type.Number() });
+      // yaml_only ignores native schemas
+      expect(() => loader.getSchema('nope', nativeInput, nativeOutput)).toThrow(SchemaNotFoundError);
+    });
+
+    it('caches getSchema results', () => {
+      writeSchema('cacheme.schema.yaml', validYaml);
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+
+      const first = loader.getSchema('cacheme');
+      const second = loader.getSchema('cacheme');
+      expect(first).toBe(second);
+    });
+  });
+
+  describe('clearCache', () => {
+    it('clears all caches so next load/getSchema reloads from disk', () => {
+      writeSchema('clearable.schema.yaml', `
+description: Clearable
+input_schema:
+  type: object
+  properties:
+    v:
+      type: string
+output_schema:
+  type: object
+`);
+      const loader = new SchemaLoader(makeConfig(), schemasDir);
+
+      const sd1 = loader.load('clearable');
+      expect(sd1.description).toBe('Clearable');
+
+      // Overwrite file
+      writeSchema('clearable.schema.yaml', `
+description: Updated
+input_schema:
+  type: object
+output_schema:
+  type: object
+`);
+
+      // Without clear, returns cached
+      const sd2 = loader.load('clearable');
+      expect(sd2.description).toBe('Clearable');
+
+      // After clear, reloads from disk
+      loader.clearCache();
+      const sd3 = loader.load('clearable');
+      expect(sd3.description).toBe('Updated');
+    });
+  });
+
+  describe('constructor', () => {
+    it('uses config schema.root when schemasDir not provided', () => {
+      writeSchema('fromconfig.schema.yaml', `
+description: From config
+input_schema:
+  type: object
+output_schema:
+  type: object
+`);
+      const config = new Config({ schema: { root: schemasDir } });
+      const loader = new SchemaLoader(config);
+      const sd = loader.load('fromconfig');
+      expect(sd.description).toBe('From config');
+    });
+
+    it('uses default ./schemas when config has no schema.root', () => {
+      const config = new Config({});
+      // This just constructs without error; actual path may not exist
+      const loader = new SchemaLoader(config);
+      expect(loader).toBeInstanceOf(SchemaLoader);
+    });
+  });
+});
 
 describe('jsonSchemaToTypeBox', () => {
   it('converts string type', () => {