@learningnodes/elen-mcp 0.1.2

package/src/tools/supersede.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import type { Elen } from '@learningnodes/elen';
+import { commitInputSchema } from './commit';
+
+export const elenSupersedeTool = {
+    name: 'elen_supersede',
+    description: 'Explicitly revise and supersede an older decision with a new one.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            oldDecisionId: { type: 'string', description: 'The old decision_id to supersede' },
+            question: { type: 'string', description: 'The question or problem statement' },
+            domain: { type: 'string', description: 'Domain of decision' },
+            decisionText: { type: 'string', description: 'The new revised answer/decision' },
+            constraints: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Plain-text constraint rules'
+            },
+            refs: {
+                type: 'array',
+                items: { type: 'string' }
+            }
+        },
+        required: ['oldDecisionId', 'question', 'domain', 'decisionText', 'constraints']
+    }
+};
+
+export const supersedeInputSchema = commitInputSchema.extend({
+    oldDecisionId: z.string().min(1)
+});
+
+export async function handleSupersede(elen: Elen, args: unknown): Promise<unknown> {
+    const parsed = supersedeInputSchema.parse(args);
+    const result = await elen.supersedeDecision(parsed.oldDecisionId, {
+        question: parsed.question,
+        domain: parsed.domain,
+        decisionText: parsed.decisionText,
+        constraints: parsed.constraints,
+        refs: parsed.refs
+    });
+    return result;
+}

package/tests/server.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it, vi } from 'vitest';
+import { parseCliArgs } from '../src/index';
+import { defaultStoragePath, routeToolCall } from '../src/server';
+
+describe('MCP server CLI', () => {
+  it('parses --agent-id and --storage args', () => {
+    const parsed = parseCliArgs(['--agent-id', 'my-agent', '--storage', '/tmp/elen.db']);
+
+    expect(parsed.agentId).toBe('my-agent');
+    expect(parsed.storagePath).toBe('/tmp/elen.db');
+  });
+
+  it('uses defaults when args are omitted', () => {
+    const parsed = parseCliArgs([]);
+
+    expect(parsed.agentId).toBe('default-agent');
+    expect(defaultStoragePath().replace(/\\/g, '/')).toContain('.elen/decisions.db');
+    expect(parsed.storagePath).toBeUndefined();
+  });
+});
+
+describe('routeToolCall', () => {
+  it('routes known tools and throws for unknown tool', async () => {
+    const elen = {
+      logDecision: vi.fn(async () => ({ record_id: 'rec-1' })),
+      searchRecords: vi.fn(async () => [{ record_id: 'rec-1' }]),
+      getCompetencyProfile: vi.fn(async () => ({ domains: [] }))
+    } as any;
+
+    await expect(routeToolCall(elen, 'agent-a', 'elen_log_decision', {
+      question: 'Q',
+      domain: 'infrastructure',
+      constraints: ['C'],
+      evidence: ['E'],
+      answer: 'A'
+    })).resolves.toMatchObject({ record_id: 'rec-1', next_suggested_action: expect.any(String) });
+
+    await expect(routeToolCall(elen, 'agent-a', 'elen_search_precedents', {})).resolves.toEqual([{ record_id: 'rec-1' }]);
+    await expect(routeToolCall(elen, 'agent-a', 'elen_get_competency', {})).resolves.toEqual({ domains: [] });
+
+    await expect(routeToolCall(elen, 'agent-a', 'unknown_tool', {})).rejects.toThrow('Unknown tool');
+  });
+});

package/tests/tools.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+  elenGetCompetencyTool,
+  elenLogDecisionTool,
+  elenSearchPrecedentsTool,
+  handleGetCompetency,
+  handleLogDecision,
+  handleSearchPrecedents,
+  validateCompetencyInput,
+  validateLogDecisionInput,
+  validateSearchInput
+} from '../src/tools';
+
+describe('MCP tool schemas', () => {
+  it('tool descriptions match expected format', () => {
+    expect(elenLogDecisionTool.description).toContain('validated Decision Record');
+    expect(elenSearchPrecedentsTool.description).toContain('validated decisions');
+    expect(elenGetCompetencyTool.description).toContain('competency profile');
+  });
+
+  it('elen_log_decision schema has required fields', () => {
+    expect(elenLogDecisionTool.inputSchema.required).toEqual(['question', 'constraints', 'evidence', 'answer']);
+  });
+
+  it('elen_search_precedents schema includes optional filters', () => {
+    expect(elenSearchPrecedentsTool.inputSchema.properties).toHaveProperty('query');
+    expect(elenSearchPrecedentsTool.inputSchema.properties).toHaveProperty('domain');
+    expect(elenSearchPrecedentsTool.inputSchema.properties).toHaveProperty('minConfidence');
+    expect(elenSearchPrecedentsTool.inputSchema.properties).toHaveProperty('limit');
+  });
+
+  it('elen_get_competency schema supports optional agentId', () => {
+    expect(elenGetCompetencyTool.inputSchema.properties).toHaveProperty('agentId');
+  });
+});
+
+describe('MCP tool handlers', () => {
+  it('elen_log_decision creates a record via SDK', async () => {
+    const elen = {
+      logDecision: vi.fn(async (input: unknown) => ({ record_id: 'rec-1', ...((input ?? {}) as object) }))
+    } as any;
+
+    const result = await handleLogDecision(elen, {
+      question: 'Which DB?',
+      domain: 'infrastructure',
+      constraints: ['Must scale'],
+      evidence: ['benchmark measured 3200 TPS'],
+      answer: 'PostgreSQL'
+    });
+
+    expect(elen.logDecision).toHaveBeenCalledOnce();
+    expect((result as { record_id: string }).record_id).toBe('rec-1');
+  });
+
+  it('elen_search_precedents returns matching records', async () => {
+    const elen = {
+      searchRecords: vi.fn(async () => [{ record_id: 'rec-a' }, { record_id: 'rec-b' }])
+    } as any;
+
+    const result = await handleSearchPrecedents(elen, { query: 'database choice', limit: 2 });
+
+    expect(elen.searchRecords).toHaveBeenCalledWith({ query: 'database choice', domain: undefined, minConfidence: undefined, limit: 2 });
+    expect(result).toHaveLength(2);
+  });
+
+  it('elen_get_competency returns profile', async () => {
+    const elen = {
+      getCompetencyProfile: vi.fn(async () => ({ domains: ['infrastructure'] }))
+    } as any;
+
+    const result = await handleGetCompetency(elen, {}, 'agent-a');
+
+    expect(elen.getCompetencyProfile).toHaveBeenCalledOnce();
+    expect((result as { domains: string[] }).domains).toContain('infrastructure');
+  });
+
+  it('throws on invalid tool inputs', () => {
+    expect(() => validateLogDecisionInput({ question: 'Q' })).toThrow('missing required field');
+    expect(() => validateSearchInput({ limit: '5' })).toThrow('limit must be a number');
+    expect(() => validateCompetencyInput({ agentId: 42 })).toThrow('agentId must be a string');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": [
+    "src"
+  ]
+}