portal/tools/observer-state-enricher.test.mjs

import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { mkdtempSync, writeFileSync, rmSync } from 'fs';
import { tmpdir } from 'os';
import { join } from 'path';
import { readRouterState } from './observer-state-enricher.mjs';

describe('readRouterState', () => {
  let baseDir;

  beforeEach(() => {
    baseDir = mkdtempSync(join(tmpdir(), 'router-state-test-'));
  });

  afterEach(() => {
    rmSync(baseDir, { recursive: true, force: true });
  });

  it('returns null when state file does not exist', () => {
    expect(readRouterState('abc-123', { baseDir })).toBeNull();
  });

  it('reads state file when present', () => {
    const state = {
      sessionId: 'abc-123',
      classification: { recommendedNode: '#62', recommendedChain: '#13' },
      chainProgress: ['brainstorming'],
      chainCompleted: false,
    };
    writeFileSync(join(baseDir, 'router-state-abc-123.json'), JSON.stringify(state));
    const result = readRouterState('abc-123', { baseDir });
    expect(result).toEqual(state);
  });

  it('returns null on malformed JSON', () => {
    writeFileSync(join(baseDir, 'router-state-broken.json'), 'not-json');
    expect(readRouterState('broken', { baseDir })).toBeNull();
  });

  it('returns null on missing sessionId', () => {
    expect(readRouterState(null, { baseDir })).toBeNull();
    expect(readRouterState('', { baseDir })).toBeNull();
  });

  it('uses ~/.claude/runtime/ as default baseDir', () => {
    // Smoke-check: default baseDir resolution doesn't throw.
    // Real-file reading covered above with explicit baseDir.
    const result = readRouterState('non-existent-session-xyz');
    // Either null (file doesn't exist there) or object — both fine.
    expect(result === null || typeof result === 'object').toBe(true);
  });
});

describe('extractRouterFields', () => {
  it('extracts the four fields from state, defaulting to null/empty', async () => {
    const { extractRouterFields } = await import('./observer-state-enricher.mjs');
    const state = {
      classification: { recommendedNode: '#62', recommendedChain: '#13' },
      chainProgress: ['brainstorming', 'writing-plans'],
      chainCompleted: false,
    };
    expect(extractRouterFields(state)).toEqual({
      recommended_node: '#62',
      recommended_chain: '#13',
      chain_progress: ['brainstorming', 'writing-plans'],
      chain_completed: false,
    });
  });

  it('returns nulls/empty when state is null', async () => {
    const { extractRouterFields } = await import('./observer-state-enricher.mjs');
    expect(extractRouterFields(null)).toEqual({
      recommended_node: null,
      recommended_chain: null,
      chain_progress: [],
      chain_completed: false,
    });
  });

  it('handles missing classification block', async () => {
    const { extractRouterFields } = await import('./observer-state-enricher.mjs');
    expect(extractRouterFields({ chainProgress: ['x'], chainCompleted: true })).toEqual({
      recommended_node: null,
      recommended_chain: null,
      chain_progress: ['x'],
      chain_completed: true,
    });
  });

  it('treats empty string recommendedNode/recommendedChain as null', async () => {
    const { extractRouterFields } = await import('./observer-state-enricher.mjs');
    expect(extractRouterFields({ classification: { recommendedNode: '', recommendedChain: '' } })).toEqual({
      recommended_node: null,
      recommended_chain: null,
      chain_progress: [],
      chain_completed: false,
    });
  });
});