@sidurijs/api 1.0.0

package/src/index.test.ts

@@ -0,0 +1,178 @@
+import request from 'supertest';
+import { createApp } from './app';
+
+describe('API Boundary Context Validation (P2 Route Integration)', () => {
+  const fakeRuntime: any = {
+    handleUserMessage: jest.fn().mockResolvedValue({
+      response: { subtitle_en: 'Hello there' },
+      metadata: {},
+    }),
+  };
+
+  let app: any;
+  let runtimes: Map<string, any>;
+
+  beforeEach(() => {
+    runtimes = new Map([['companion-a', fakeRuntime]]);
+    const created = createApp(runtimes);
+    app = created.app;
+    fakeRuntime.handleUserMessage.mockClear();
+  });
+
+  test('accepts valid anonymous chat request and maps through API boundary', async () => {
+    const res = await request(app)
+      .post('/chat')
+      .send({
+        id: 'companion-a',
+        message: 'Hello neutral world',
+        history: [],
+      });
+
+    expect(res.status).toBe(200);
+    expect(fakeRuntime.handleUserMessage).toHaveBeenCalledWith(
+      'Hello neutral world',
+      expect.objectContaining({
+        companionId: 'companion-a',
+        conversation: expect.objectContaining({ channel: 'direct' }),
+      }),
+      []
+    );
+  });
+
+  test('accepts neutral context chat envelope at /chat route', async () => {
+    const res = await request(app)
+      .post('/chat')
+      .send({
+        companionId: 'companion-a',
+        context: {
+          actor: {
+            actorId: 'actor-a',
+            sessionId: 'session-a',
+            authorizationRole: 'viewer',
+            capabilities: ['chat:public'],
+            authenticated: false,
+          },
+          conversation: {
+            channel: 'public',
+            correlationId: 'corr-route-1',
+          },
+        },
+        message: 'Hello structured context',
+        history: [],
+      });
+
+    expect(res.status).toBe(200);
+    expect(fakeRuntime.handleUserMessage).toHaveBeenCalledWith(
+      'Hello structured context',
+      expect.objectContaining({
+        companionId: 'companion-a',
+        conversation: expect.objectContaining({ channel: 'public' }),
+      }),
+      []
+    );
+  });
+
+  test('rejects global primary_user subject with 400 and structured error', async () => {
+    const res = await request(app)
+      .post('/chat')
+      .send({
+        companionId: 'companion-a',
+        context: {
+          actor: {
+            actorId: 'actor-a',
+            sessionId: 'session-a',
+            authorizationRole: 'viewer',
+            capabilities: ['chat:public'],
+            authenticated: true,
+          },
+          conversation: {
+            channel: 'public',
+            correlationId: 'corr-err-2',
+          },
+          subject: {
+            subjectId: 'primary_user',
+            kind: 'actor',
+          },
+        },
+        message: 'Forbidden primary user test',
+      });
+
+    expect(res.status).toBe(400);
+    expect(res.body.accepted).toBe(false);
+    expect(res.body.error.code).toBe('FORBIDDEN_CONTEXT');
+    expect(fakeRuntime.handleUserMessage).not.toHaveBeenCalled();
+  });
+
+  test('streams response chunks via POST /chat/stream', async () => {
+    fakeRuntime.mouth = {
+      stream: async function* () {
+        yield { utteranceId: 'utt-1', index: 1, deltaText: 'Hello', isComplete: false, medium: 'web' };
+        yield { utteranceId: 'utt-1', index: 2, deltaText: ' world', isComplete: false, medium: 'web' };
+        yield { utteranceId: 'utt-1', index: 3, deltaText: '', isComplete: true, medium: 'web' };
+      },
+    };
+
+    const res = await request(app)
+      .post('/chat/stream')
+      .send({
+        id: 'companion-a',
+        message: 'Stream me',
+      });
+
+    expect(res.status).toBe(200);
+    expect(res.headers['content-type']).toContain('text/event-stream');
+    expect(res.text).toContain('event: staged');
+    expect(res.text).toContain('event: chunk');
+    expect(res.text).toContain('event: done');
+  });
+
+  test('handles barge-in interruption via POST /chat/interrupt', async () => {
+    fakeRuntime.mouth = { interrupt: jest.fn() };
+
+    const res = await request(app)
+      .post('/chat/interrupt')
+      .send({
+        companionId: 'companion-a',
+        reason: 'user_stop',
+      });
+
+    expect(res.status).toBe(200);
+    expect(res.body.interrupted).toBe(true);
+    expect(fakeRuntime.mouth.interrupt).toHaveBeenCalledWith('user_stop');
+  });
+
+  test('handles mouth interruption via POST /mouth/interrupt', async () => {
+    fakeRuntime.mouth = { interrupt: jest.fn() };
+
+    const res = await request(app)
+      .post('/mouth/interrupt')
+      .send({
+        companionId: 'companion-a',
+        reason: 'user_barge_in',
+      });
+
+    expect(res.status).toBe(200);
+    expect(res.body.interrupted).toBe(true);
+    expect(fakeRuntime.mouth.interrupt).toHaveBeenCalledWith('user_barge_in');
+  });
+
+  test('POST /chat passes explicit interaction mode (casual, teach, hybrid) to runtime', async () => {
+    const res = await request(app)
+      .post('/chat')
+      .send({
+        id: 'companion-a',
+        message: 'Casual banter',
+        mode: 'casual',
+      });
+
+    expect(res.status).toBe(200);
+    expect(fakeRuntime.handleUserMessage).toHaveBeenCalledWith(
+      'Casual banter',
+      expect.objectContaining({
+        companionId: 'companion-a',
+        mode: 'casual',
+      }),
+      []
+    );
+  });
+});

package/src/index.ts

@@ -0,0 +1,101 @@
+import dotenv from 'dotenv';
+dotenv.config({ override: true });
+
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { Express } from 'express';
+import { createApp, AppInstance } from './app';
+import { SiduriRuntime } from './runtime';
+import { bootCompanion, createVision, createObservation } from './boot';
+
+export { createApp, AppInstance };
+export * from './context-mapper';
+export * from './boot';
+
+const runtimes = new Map<string, SiduriRuntime>();
+const instance: AppInstance = createApp(runtimes);
+export const app: Express = instance.app;
+export default app;
+
+const PORT = process.env.PORT || 3001;
+
+const defaultCompanionConfig = {
+  id: 'default',
+  name: 'Siduri',
+  brain: { provider: 'openrouter', model: 'gpt-4o-mini' },
+  voice: { provider: 'voicevox', speakerId: 1 },
+  memory: { provider: 'sqlite' },
+  knowledge: {
+    provider: (process.env.SIDURI_KNOWLEDGE_PROVIDER as any) || 'unified',
+    lifeDatabase: true,
+    dbPath: process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite',
+    packPath: process.env.SIDURI_KNOWLEDGE_PACK || '',
+    registryUrl: process.env.SIDURI_KNOWLEDGE_REGISTRY_URL || '',
+    packId: process.env.SIDURI_KNOWLEDGE_PACK_ID || '',
+    timeoutMs: Number(process.env.SIDURI_KNOWLEDGE_TIMEOUT_MS || 5000),
+    preferredMode: (process.env.SIDURI_KNOWLEDGE_MODE as 'lexical' | 'semantic' | 'hybrid') || 'lexical',
+  },
+  behavior: { provider: 'active_self' },
+  body: {
+    provider: 'live2d',
+  },
+  vision: { provider: 'openrouter', model: 'gpt-4-vision' }
+};
+
+async function loadCompanionConfig() {
+  const configPath = process.env.SIDURI_CONFIG || path.resolve(process.cwd(), 'siduri.config.json');
+  let fileConfig: Record<string, any> = {};
+  try {
+    fileConfig = JSON.parse(await readFile(configPath, 'utf8')) as Record<string, any>;
+    console.log(`Loaded companion configuration from ${configPath}`);
+  } catch (error: any) {
+    if (error?.code !== 'ENOENT') throw new Error(`Unable to read ${configPath}: ${error.message}`);
+    console.log(`No ${configPath} found; using environment/default configuration.`);
+  }
+
+  const config: any = {
+    ...defaultCompanionConfig,
+    ...fileConfig,
+    id: fileConfig.id || defaultCompanionConfig.id,
+    brain: { ...defaultCompanionConfig.brain, ...fileConfig.brain },
+    voice: { ...defaultCompanionConfig.voice, ...fileConfig.voice },
+    memory: { ...defaultCompanionConfig.memory, ...fileConfig.memory },
+    knowledge: { ...defaultCompanionConfig.knowledge, ...fileConfig.knowledge },
+    behavior: { ...defaultCompanionConfig.behavior, ...fileConfig.behavior },
+    body: { ...defaultCompanionConfig.body, ...fileConfig.body },
+    vision: { ...defaultCompanionConfig.vision, ...fileConfig.vision },
+  };
+
+  if (process.env.SIDURI_KNOWLEDGE_PROVIDER) config.knowledge.provider = process.env.SIDURI_KNOWLEDGE_PROVIDER;
+  if (process.env.SIDURI_KNOWLEDGE_PACK) config.knowledge.packPath = process.env.SIDURI_KNOWLEDGE_PACK;
+  if (process.env.SIDURI_KNOWLEDGE_REGISTRY_URL) config.knowledge.registryUrl = process.env.SIDURI_KNOWLEDGE_REGISTRY_URL;
+  if (process.env.SIDURI_KNOWLEDGE_PACK_ID) config.knowledge.packId = process.env.SIDURI_KNOWLEDGE_PACK_ID;
+  if (process.env.SIDURI_KNOWLEDGE_MODE) config.knowledge.preferredMode = process.env.SIDURI_KNOWLEDGE_MODE;
+  if (process.env.SIDURI_KNOWLEDGE_DB_PATH) config.knowledge.dbPath = process.env.SIDURI_KNOWLEDGE_DB_PATH;
+  return config;
+}
+
+async function bootDefaultCompanion() {
+  if (runtimes.has('default')) return;
+  console.log("Booting default companion...");
+  const config: any = await loadCompanionConfig();
+
+  const vision = createVision(config.vision);
+  const observation = createObservation(vision);
+  instance.setObservationOrgan(observation);
+
+  const runtime = await bootCompanion('default', config, { observationOrgan: observation });
+  runtimes.set('default', runtime);
+  console.log("Default companion booted successfully.");
+}
+
+if (process.env.NODE_ENV !== 'test') {
+  bootDefaultCompanion().then(() => {
+    app.listen(Number(PORT), '127.0.0.1', () => {
+      console.log(`Siduri-X API running on port ${PORT} (127.0.0.1)`);
+    });
+  }).catch(e => {
+    console.error("Failed to boot default companion:", e);
+    process.exit(1);
+  });
+}

package/src/knowledge.test.ts

@@ -0,0 +1,267 @@
+import request from 'supertest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createApp } from './app';
+import { SiduriRuntime } from './runtime';
+import { UnifiedKnowledgeOrgan } from '@sidurijs/knowledge';
+
+describe('Life Database & UnifiedKnowledgeOrgan API Integration', () => {
+  const testDbPath = path.resolve(__dirname, '../test-api-knowledge.sqlite');
+  let app: any;
+  let runtime: SiduriRuntime;
+  let knowledge: UnifiedKnowledgeOrgan;
+  const mockAuthHeader = { 'Authorization': 'Bearer test-token' };
+
+  const cleanDb = () => {
+    for (const file of [testDbPath, `${testDbPath}-shm`, `${testDbPath}-wal`]) {
+      if (fs.existsSync(file)) {
+        try { fs.unlinkSync(file); } catch {}
+      }
+    }
+  };
+
+  beforeAll(async () => {
+    process.env.AUTH_TOKEN = 'test-token';
+    cleanDb();
+
+    knowledge = new UnifiedKnowledgeOrgan({
+      lifeDatabase: true,
+      dbPath: testDbPath,
+    });
+
+    const mockBrain: any = {
+      generatePlan: jest.fn().mockImplementation(async (ctx: any) => {
+        return {
+          speech: `I see context: ${ctx.contextPrompt || 'none'}`,
+          language: 'en',
+        };
+      }),
+    };
+
+    const memory: any = {
+      initialize: async () => {},
+      proposeClaim: async (claim: any) => (knowledge.lifeDb as any).db.proposeClaim(claim),
+      getClaims: async (limit?: number) => (knowledge.lifeDb as any).db.getAllClaims(undefined, limit || 500),
+      getPendingClaims: async (limit?: number) =>
+        (knowledge.lifeDb as any).db.getAllClaims(undefined, limit || 500).filter((c: any) => c.status === 'pending'),
+      approveClaim: async (id: string) => (knowledge.lifeDb as any).db.approveClaim(id),
+      rejectClaim: async (id: string) => (knowledge.lifeDb as any).db.rejectClaim(id),
+      searchClaims: async () => [],
+      getApprovedClaims: async () => [],
+      getDirectives: async () => [],
+    };
+
+    runtime = new SiduriRuntime(
+      'test-comp',
+      { name: 'Test Companion', organs: { knowledge: { provider: 'unified', dbPath: testDbPath } } } as any,
+      {
+        brain: mockBrain,
+        knowledge,
+        externalKnowledge: knowledge.eAdapter ?? knowledge,
+        memory,
+      }
+    );
+    await runtime.initialize();
+
+    const runtimes = new Map([['test-comp', runtime]]);
+    const instance = createApp(runtimes);
+    app = instance.app;
+  });
+
+  afterAll(async () => {
+    knowledge.close();
+    delete process.env.AUTH_TOKEN;
+    cleanDb();
+  });
+
+  test('seeds inventory item and queries via GET /knowledge/inventory', async () => {
+    await knowledge.inventory.saveItem({
+      id: 'inv-item-1',
+      companionId: 'test-comp',
+      entityName: 'Hydro Visor',
+      domain: 'hardware',
+      properties: { model: 'V1', resolution: '4K' },
+      updatedAt: new Date().toISOString(),
+    });
+
+    const res = await request(app)
+      .get('/knowledge/inventory?id=test-comp')
+      .set(mockAuthHeader);
+
+    expect(res.status).toBe(200);
+    expect(res.body.items).toHaveLength(1);
+    expect(res.body.items[0].entityName).toBe('Hydro Visor');
+    expect(res.body.items[0].domain).toBe('hardware');
+  });
+
+  test('seeds finance entry and queries via GET /knowledge/finance', async () => {
+    await knowledge.finance.addEntry({
+      id: 'fin-1',
+      companionId: 'test-comp',
+      category: 'subscription',
+      amount: -15.99,
+      currency: 'USD',
+      timestamp: new Date().toISOString(),
+    });
+
+    const res = await request(app)
+      .get('/knowledge/finance?id=test-comp')
+      .set(mockAuthHeader);
+
+    expect(res.status).toBe(200);
+    expect(res.body.entries).toHaveLength(1);
+    expect(res.body.entries[0].category).toBe('subscription');
+    expect(res.body.summary).toBeDefined();
+    expect(res.body.summary.totalExpenses).toBe(15.99);
+  });
+
+  test('queries life snapshot via GET /knowledge/life', async () => {
+    const res = await request(app)
+      .get('/knowledge/life?id=test-comp&q=Hydro')
+      .set(mockAuthHeader);
+
+    expect(res.status).toBe(200);
+    expect(res.body.matchedInventory).toHaveLength(1);
+    expect(res.body.matchedInventory[0].entityName).toBe('Hydro Visor');
+    expect(res.body.formattedContext).toContain('<life_context>');
+  });
+
+  test('chat request triggers Stream D and injects Life DB context into cognition prompt', async () => {
+    const res = await request(app)
+      .post('/chat')
+      .send({
+        id: 'test-comp',
+        message: 'Tell me about the Hydro Visor specs',
+        history: [],
+      });
+
+    expect(res.status).toBe(200);
+    expect(res.body.response.subtitle_en).toContain('Hydro Visor');
+  });
+
+  test('boot endpoint instantiates UnifiedKnowledgeOrgan with Life DB enabled', async () => {
+    const bootRes = await request(app)
+      .post('/boot')
+      .set(mockAuthHeader)
+      .send({
+        id: 'booted-comp',
+        config: {
+          name: 'Booted Companion',
+          organs: {
+            knowledge: {
+              provider: 'unified',
+              dbPath: testDbPath,
+            },
+          },
+        },
+      });
+
+    expect(bootRes.status).toBe(200);
+    expect(bootRes.body.success).toBe(true);
+
+    // Verify the booted companion's knowledge organ is UnifiedKnowledgeOrgan with working Life DB
+    const lifeRes = await request(app)
+      .get('/knowledge/life?id=booted-comp')
+      .set(mockAuthHeader);
+
+    expect(lifeRes.status).toBe(200);
+    expect(lifeRes.body.matchedInventory).toEqual([]);
+  });
+
+  test('seeds and queries generic entities, events, and tasks', async () => {
+    // 1. Entities
+    await knowledge.entities.saveEntity({
+      id: 'ent-1',
+      companionId: 'test-comp',
+      name: 'Coffee Grinder',
+      entityType: 'item',
+      domain: 'kitchen',
+      properties: { burr: 'conical', setting: 14 },
+    });
+
+    const entRes = await request(app)
+      .get('/knowledge/entities?id=test-comp&domain=kitchen')
+      .set(mockAuthHeader);
+    expect(entRes.status).toBe(200);
+    expect(entRes.body.entities).toHaveLength(1);
+    expect(entRes.body.entities[0].name).toBe('Coffee Grinder');
+    expect(entRes.body.entities[0].properties.setting).toBe(14);
+
+    // 2. Events
+    await knowledge.events.addEvent({
+      id: 'evt-1',
+      companionId: 'test-comp',
+      stream: 'health:heartrate',
+      timestamp: new Date().toISOString(),
+      metricValue: 72,
+      metadata: { unit: 'bpm' },
+    });
+
+    const evtRes = await request(app)
+      .get('/knowledge/events?id=test-comp&stream=health:heartrate')
+      .set(mockAuthHeader);
+    expect(evtRes.status).toBe(200);
+    expect(evtRes.body.events).toHaveLength(1);
+    expect(evtRes.body.events[0].metricValue).toBe(72);
+
+    // 3. Tasks
+    await knowledge.tasks.saveTask({
+      id: 'task-1',
+      companionId: 'test-comp',
+      title: 'Order fresh espresso beans',
+      status: 'pending',
+      priority: 2,
+    });
+
+    const taskRes = await request(app)
+      .get('/knowledge/tasks?id=test-comp&status=pending')
+      .set(mockAuthHeader);
+    expect(taskRes.status).toBe(200);
+    expect(taskRes.body.tasks).toHaveLength(1);
+    expect(taskRes.body.tasks[0].title).toBe('Order fresh espresso beans');
+  });
+
+  test('Truth Gate candidate proposal approval commits Life DB mutations', async () => {
+    // Stage a candidate proposal targeting Life DB
+    const proposal = await (knowledge.lifeDb as any).db.proposeClaim({
+      id: 'prop-task-gate',
+      companionId: 'test-comp',
+      subject: 'task:buy-filter',
+      predicate: 'is',
+      value: 'Buy paper filters',
+      status: 'pending',
+      evidence: {
+        type: 'task',
+        title: 'Buy paper filters',
+        status: 'todo',
+        priority: 1,
+      },
+    });
+    expect(proposal.status).toBe('pending');
+
+    // Confirm it is not yet in tasks
+    const beforeRes = await request(app)
+      .get('/knowledge/tasks?id=test-comp')
+      .set(mockAuthHeader);
+    expect(beforeRes.body.tasks.some((t: any) => t.title === 'Buy paper filters')).toBe(false);
+
+    // Approve via Truth Gate endpoint
+    const approveRes = await request(app)
+      .post('/knowledge/proposals/approve')
+      .set(mockAuthHeader)
+      .send({ companionId: 'test-comp', id: 'prop-task-gate' });
+
+    expect(approveRes.status).toBe(200);
+    expect(approveRes.body.approved).toBe(true);
+    expect(approveRes.body.target).toBe('knowledge');
+
+    // Confirm it is committed to Life DB tasks
+    const afterRes = await request(app)
+      .get('/knowledge/tasks?id=test-comp')
+      .set(mockAuthHeader);
+    expect(afterRes.status).toBe(200);
+    const approvedTask = afterRes.body.tasks.find((t: any) => t.title === 'Buy paper filters');
+    expect(approvedTask).toBeDefined();
+    expect(approvedTask.status).toBe('todo');
+  });
+});