@monotykamary/pi-supervisor 0.5.9

package/tests/global-config.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { loadGlobalModel, saveGlobalModel } from '../src/global-config.js';
+
+describe('global-config', () => {
+  let tmp: string;
+  let cwdSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'pi-supervisor-cfg-'));
+    cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue(tmp);
+  });
+
+  afterEach(() => {
+    cwdSpy.mockRestore();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('loadGlobalModel returns null when no config exists', () => {
+    expect(loadGlobalModel()).toBeNull();
+  });
+
+  it('saveGlobalModel returns the written config path', () => {
+    const path = saveGlobalModel(tmp, { provider: 'openai', modelId: 'gpt-4o' });
+    expect(path).toBe(join(tmp, '.pi', 'supervisor-config.json'));
+    expect(existsSync(path)).toBe(true);
+  });
+
+  it('loadGlobalModel reads back what saveGlobalModel wrote', () => {
+    saveGlobalModel(tmp, { provider: 'anthropic', modelId: 'claude-sonnet-4' });
+    expect(loadGlobalModel()).toEqual({ provider: 'anthropic', modelId: 'claude-sonnet-4' });
+  });
+
+  it('saveGlobalModel creates the .pi directory when missing', () => {
+    expect(existsSync(join(tmp, '.pi'))).toBe(false);
+    saveGlobalModel(tmp, { provider: 'openai', modelId: 'gpt-4.1' });
+    expect(existsSync(join(tmp, '.pi'))).toBe(true);
+  });
+
+  it('saveGlobalModel preserves other keys already present in the config', () => {
+    const configPath = join(tmp, '.pi', 'supervisor-config.json');
+    mkdirSync(join(tmp, '.pi'), { recursive: true });
+    writeFileSync(configPath, JSON.stringify({ otherKey: 'keep' }, null, 2));
+
+    saveGlobalModel(tmp, { provider: 'openai', modelId: 'gpt-4o' });
+
+    const parsed = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(parsed.otherKey).toBe('keep');
+    expect(parsed.model).toEqual({ provider: 'openai', modelId: 'gpt-4o' });
+  });
+
+  it('saveGlobalModel overwrites a previously saved model', () => {
+    saveGlobalModel(tmp, { provider: 'openai', modelId: 'gpt-4o' });
+    saveGlobalModel(tmp, { provider: 'anthropic', modelId: 'claude-haiku' });
+    expect(loadGlobalModel()).toEqual({ provider: 'anthropic', modelId: 'claude-haiku' });
+  });
+
+  it('loadGlobalModel returns null for an invalid JSON config', () => {
+    mkdirSync(join(tmp, '.pi'), { recursive: true });
+    writeFileSync(join(tmp, '.pi', 'supervisor-config.json'), '{ not json');
+    expect(loadGlobalModel()).toBeNull();
+  });
+
+  it('loadGlobalModel returns null when the model field is incomplete', () => {
+    mkdirSync(join(tmp, '.pi'), { recursive: true });
+    writeFileSync(
+      join(tmp, '.pi', 'supervisor-config.json'),
+      JSON.stringify({ model: { provider: 'openai' } })
+    );
+    expect(loadGlobalModel()).toBeNull();
+  });
+});

package/tests/model-sort.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+
+// Mock node:fs so readModelSortLastUsed can be tested in isolation.
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+}));
+
+import { existsSync, readFileSync } from 'node:fs';
+import {
+  buildModelKey,
+  hasUsageData,
+  readModelSortLastUsed,
+  sortByLastUsed,
+} from '../src/ui/model-sort.js';
+
+const mockedExists = vi.mocked(existsSync);
+const mockedRead = vi.mocked(readFileSync);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('buildModelKey', () => {
+  it('builds a key from provider and model id', () => {
+    expect(buildModelKey('anthropic', 'claude-sonnet-4')).toBe('anthropic/claude-sonnet-4');
+  });
+
+  it('preserves slashes in model ids (e.g. openrouter proxy ids)', () => {
+    expect(buildModelKey('openrouter', 'anthropic/claude-sonnet-4')).toBe(
+      'openrouter/anthropic/claude-sonnet-4'
+    );
+  });
+});
+
+describe('hasUsageData', () => {
+  it('returns false for null', () => {
+    expect(hasUsageData(null)).toBe(false);
+  });
+
+  it('returns false for an empty map', () => {
+    expect(hasUsageData({})).toBe(false);
+  });
+
+  it('returns true for a non-empty map', () => {
+    expect(hasUsageData({ 'openai/gpt-4o': 1 })).toBe(true);
+  });
+});
+
+describe('readModelSortLastUsed', () => {
+  it('returns null when the config file does not exist', () => {
+    mockedExists.mockReturnValue(false);
+    expect(readModelSortLastUsed()).toBeNull();
+    expect(mockedRead).not.toHaveBeenCalled();
+  });
+
+  it('returns null when the config is not valid JSON', () => {
+    mockedExists.mockReturnValue(true);
+    mockedRead.mockReturnValue('not json');
+    expect(readModelSortLastUsed()).toBeNull();
+  });
+
+  it('returns null when lastUsed is missing', () => {
+    mockedExists.mockReturnValue(true);
+    mockedRead.mockReturnValue(JSON.stringify({}));
+    expect(readModelSortLastUsed()).toBeNull();
+  });
+
+  it('returns null when lastUsed is not an object', () => {
+    mockedExists.mockReturnValue(true);
+    mockedRead.mockReturnValue(JSON.stringify({ lastUsed: 'nope' }));
+    expect(readModelSortLastUsed()).toBeNull();
+  });
+
+  it('returns the lastUsed map when present', () => {
+    const lastUsed = { 'openai/gpt-4o': 100, 'anthropic/claude-sonnet-4': 200 };
+    mockedExists.mockReturnValue(true);
+    mockedRead.mockReturnValue(JSON.stringify({ lastUsed }));
+    expect(readModelSortLastUsed()).toEqual(lastUsed);
+  });
+});
+
+describe('sortByLastUsed', () => {
+  const models = [
+    { provider: 'anthropic', id: 'claude-opus-4' },
+    { provider: 'anthropic', id: 'claude-sonnet-4' },
+    { provider: 'openai', id: 'gpt-4o' },
+    { provider: 'google', id: 'gemini-2.5-pro' },
+    { provider: 'openai', id: 'gpt-4.1' },
+  ];
+
+  it('sorts by last-used descending when all have timestamps', () => {
+    const lastUsed = {
+      'google/gemini-2.5-pro': 300,
+      'openai/gpt-4.1': 500,
+      'openai/gpt-4o': 100,
+      'anthropic/claude-sonnet-4': 400,
+      'anthropic/claude-opus-4': 200,
+    };
+    const sorted = sortByLastUsed(models, lastUsed, null);
+    expect(sorted.map((m) => `${m.provider}/${m.id}`)).toEqual([
+      'openai/gpt-4.1',
+      'anthropic/claude-sonnet-4',
+      'google/gemini-2.5-pro',
+      'anthropic/claude-opus-4',
+      'openai/gpt-4o',
+    ]);
+  });
+
+  it('puts the current model first, ahead of more-recent models', () => {
+    const lastUsed = {
+      'openai/gpt-4.1': 500,
+      'openai/gpt-4o': 100,
+    };
+    const sorted = sortByLastUsed(models, lastUsed, 'google/gemini-2.5-pro');
+    expect(sorted[0]).toEqual({ provider: 'google', id: 'gemini-2.5-pro' });
+  });
+
+  it('falls back to provider/id alphabetical for equal or missing timestamps', () => {
+    const lastUsed: Record<string, number> = {};
+    const sorted = sortByLastUsed(models, lastUsed, null);
+    expect(sorted.map((m) => `${m.provider}/${m.id}`)).toEqual([
+      'anthropic/claude-opus-4',
+      'anthropic/claude-sonnet-4',
+      'google/gemini-2.5-pro',
+      'openai/gpt-4.1',
+      'openai/gpt-4o',
+    ]);
+  });
+
+  it('sorts unused models last, alphabetically within the unused group', () => {
+    const lastUsed = {
+      'openai/gpt-4o': 500,
+    };
+    const sorted = sortByLastUsed(models, lastUsed, null);
+    expect(sorted.map((m) => `${m.provider}/${m.id}`)).toEqual([
+      'openai/gpt-4o',
+      'anthropic/claude-opus-4',
+      'anthropic/claude-sonnet-4',
+      'google/gemini-2.5-pro',
+      'openai/gpt-4.1',
+    ]);
+  });
+
+  it('does not mutate the input array', () => {
+    const lastUsed = { 'openai/gpt-4o': 100 };
+    const input = models.map((m) => ({ ...m }));
+    sortByLastUsed(models, lastUsed, null);
+    expect(models).toEqual(input);
+  });
+
+  it('returns the same length as the input', () => {
+    const lastUsed = { 'openai/gpt-4o': 100 };
+    const sorted = sortByLastUsed(models, lastUsed, null);
+    expect(sorted).toHaveLength(models.length);
+  });
+});

package/tests/parsing.test.ts

@@ -0,0 +1,303 @@
+import { describe, expect, it } from 'vitest';
+import { parseDecision } from '../src/session/response-parser.js';
+import { extractThinking } from '../src/index.js';
+
+describe('parseDecision', () => {
+  it('parses valid continue response', () => {
+    const text = JSON.stringify({
+      action: 'continue',
+      reasoning: 'Making good progress',
+      confidence: 0.9,
+    });
+
+    const result = parseDecision(text);
+    expect(result.action).toBe('continue');
+    expect(result.reasoning).toBe('Making good progress');
+    expect(result.confidence).toBe(0.9);
+    expect(result.message).toBeUndefined();
+  });
+
+  it('parses valid steer response', () => {
+    const text = JSON.stringify({
+      action: 'steer',
+      message: 'Focus on the tests first',
+      reasoning: 'Agent is skipping tests',
+      confidence: 0.95,
+    });
+
+    const result = parseDecision(text);
+    expect(result.action).toBe('steer');
+    expect(result.message).toBe('Focus on the tests first');
+    expect(result.reasoning).toBe('Agent is skipping tests');
+    expect(result.confidence).toBe(0.95);
+  });
+
+  it('parses valid done response', () => {
+    const text = JSON.stringify({
+      action: 'done',
+      reasoning: 'Goal achieved',
+      confidence: 0.99,
+    });
+
+    const result = parseDecision(text);
+    expect(result.action).toBe('done');
+    expect(result.reasoning).toBe('Goal achieved');
+    expect(result.confidence).toBe(0.99);
+  });
+
+  it('extracts JSON from markdown code block', () => {
+    const json = JSON.stringify({
+      action: 'steer',
+      message: 'Fix the error',
+      reasoning: 'Test failed',
+      confidence: 0.85,
+    });
+    const text = '```json\n' + json + '\n```';
+
+    const result = parseDecision(text);
+    expect(result.action).toBe('steer');
+    expect(result.message).toBe('Fix the error');
+  });
+
+  it('extracts JSON from plain code block', () => {
+    const json = JSON.stringify({
+      action: 'continue',
+      reasoning: 'On track',
+      confidence: 0.8,
+    });
+    const text = '```\n' + json + '\n```';
+
+    const result = parseDecision(text);
+    expect(result.action).toBe('continue');
+  });
+
+  it('extracts JSON from curly braces when no code block', () => {
+    const text =
+      'Some text before { "action": "steer", "message": "Help", "reasoning": "Test", "confidence": 0.7 } some after';
+
+    const result = parseDecision(text);
+    expect(result.action).toBe('steer');
+    expect(result.message).toBe('Help');
+  });
+
+  it('returns continue on invalid JSON', () => {
+    const text = 'not valid json at all';
+
+    const result = parseDecision(text);
+    expect(result.action).toBe('continue');
+    expect(result.reasoning).toBe('Failed to parse supervisor JSON decision');
+    expect(result.confidence).toBe(0);
+  });
+
+  it('returns continue on invalid action', () => {
+    const text = JSON.stringify({
+      action: 'invalid',
+      reasoning: 'Something',
+      confidence: 0.5,
+    });
+
+    const result = parseDecision(text);
+    expect(result.action).toBe('continue');
+    expect(result.reasoning).toBe('Invalid action in supervisor response');
+  });
+
+  it('handles missing fields with defaults', () => {
+    const text = JSON.stringify({
+      action: 'continue',
+    });
+
+    const result = parseDecision(text);
+    expect(result.action).toBe('continue');
+    expect(result.reasoning).toBe('');
+    expect(result.confidence).toBe(0.5);
+    expect(result.message).toBeUndefined();
+  });
+
+  it('trims message whitespace', () => {
+    const text = JSON.stringify({
+      action: 'steer',
+      message: '  Message with whitespace  ',
+      reasoning: 'Test',
+      confidence: 0.8,
+    });
+
+    const result = parseDecision(text);
+    expect(result.message).toBe('Message with whitespace');
+  });
+
+  it('handles escaped quotes in reasoning', () => {
+    const text = JSON.stringify({
+      action: 'steer',
+      message: 'Say "hello"',
+      reasoning: 'The agent said "test"',
+      confidence: 0.9,
+    });
+
+    const result = parseDecision(text);
+    expect(result.message).toBe('Say "hello"');
+    expect(result.reasoning).toBe('The agent said "test"');
+  });
+
+  it('parses ASI from steer response', () => {
+    const text = JSON.stringify({
+      action: 'steer',
+      message: 'Focus on tests',
+      reasoning: 'Agent drifting',
+      confidence: 0.9,
+      asi: {
+        why_stuck: 'refactoring without tests',
+        strategy_used: 'directive',
+        pattern_detected: 'test_skipping',
+        confidence_source: 'no test files added',
+        would_escalate_sooner: false,
+        custom_key: 'custom_value',
+      },
+    });
+
+    const result = parseDecision(text);
+    expect(result.asi).toBeDefined();
+    expect(result.asi!.why_stuck).toBe('refactoring without tests');
+    expect(result.asi!.strategy_used).toBe('directive');
+    expect(result.asi!.pattern_detected).toBe('test_skipping');
+    expect(result.asi!.would_escalate_sooner).toBe(false);
+    expect(result.asi!.custom_key).toBe('custom_value');
+  });
+
+  it('handles missing ASI gracefully', () => {
+    const text = JSON.stringify({
+      action: 'steer',
+      message: 'Focus',
+      reasoning: 'Test',
+      confidence: 0.8,
+    });
+
+    const result = parseDecision(text);
+    expect(result.asi).toBeUndefined();
+  });
+
+  it('handles ASI with only partial fields', () => {
+    const text = JSON.stringify({
+      action: 'done',
+      reasoning: 'Complete',
+      confidence: 0.99,
+      asi: {
+        why_stuck: 'already done',
+      },
+    });
+
+    const result = parseDecision(text);
+    expect(result.asi).toBeDefined();
+    expect(result.asi!.why_stuck).toBe('already done');
+    expect(result.asi!.strategy_used).toBeUndefined();
+  });
+
+  it('parses free-form ASI with arbitrary keys for cheating detection', () => {
+    const text = JSON.stringify({
+      action: 'steer',
+      message: 'Verify your claim',
+      reasoning: 'Suspicious unverified claim',
+      confidence: 0.9,
+      asi: {
+        suspicious_claim_detected: true,
+        claim_type: 'unverified_test_success',
+        evidence: 'agent_said_tests_pass_but_exit_code_1',
+        previous_contradiction_turn: 3,
+        watch_for: 'fake_test_results',
+        custom_observation: 'agent_removed_assertions_in_same_turn',
+      },
+    });
+
+    const result = parseDecision(text);
+    expect(result.asi).toBeDefined();
+    expect(result.asi!.suspicious_claim_detected).toBe(true);
+    expect(result.asi!.claim_type).toBe('unverified_test_success');
+    expect(result.asi!.evidence).toBe('agent_said_tests_pass_but_exit_code_1');
+    expect(result.asi!.previous_contradiction_turn).toBe(3);
+    expect(result.asi!.watch_for).toBe('fake_test_results');
+    expect(result.asi!.custom_observation).toBe('agent_removed_assertions_in_same_turn');
+  });
+
+  it('parses ASI with cheating-related keywords', () => {
+    const text = JSON.stringify({
+      action: 'steer',
+      message: 'Do not manipulate tests',
+      reasoning: 'Test manipulation detected',
+      confidence: 0.95,
+      asi: {
+        pattern: 'test_manipulation',
+        indicator: 'fake',
+        observation: 'agent_gaming_the_metrics',
+        status: 'unverified_claim',
+        severity: 'high',
+      },
+    });
+
+    const result = parseDecision(text);
+    expect(result.asi).toBeDefined();
+    expect(result.asi!.pattern).toBe('test_manipulation');
+    expect(result.asi!.indicator).toBe('fake');
+    expect(result.asi!.observation).toBe('agent_gaming_the_metrics');
+    expect(result.asi!.status).toBe('unverified_claim');
+  });
+});
+
+describe('extractThinking', () => {
+  it('returns empty string when no reasoning key', () => {
+    const text = '{ "action": "continue" }';
+    expect(extractThinking(text)).toBe('');
+  });
+
+  it('extracts reasoning from complete JSON', () => {
+    const text = JSON.stringify({
+      action: 'steer',
+      message: 'Focus',
+      reasoning: 'The agent is drifting from the goal',
+      confidence: 0.9,
+    });
+
+    expect(extractThinking(text)).toBe('The agent is drifting from the goal');
+  });
+
+  it('extracts reasoning from streaming partial JSON (no closing quote)', () => {
+    const text = '{ "action": "steer", "reasoning": "The agent is working on';
+
+    expect(extractThinking(text)).toBe('The agent is working on');
+  });
+
+  it('extracts reasoning with spaces around colon', () => {
+    const text = '{ "reasoning" : "Test reasoning" }';
+
+    expect(extractThinking(text)).toBe('Test reasoning');
+  });
+
+  it('returns empty string for malformed reasoning key', () => {
+    const text = '{ "reasoning": 123 }'; // Not a string
+
+    expect(extractThinking(text)).toBe('');
+  });
+
+  it('handles escaped newlines in reasoning', () => {
+    const text = JSON.stringify({
+      reasoning: 'Line 1\nLine 2',
+    });
+
+    expect(extractThinking(text)).toBe('Line 1 Line 2');
+  });
+
+  it('handles escaped quotes in reasoning', () => {
+    const text = '{ "reasoning": "The agent said \\"test\\" here" }';
+
+    expect(extractThinking(text)).toBe('The agent said "test" here');
+  });
+
+  it('extracts reasoning that appears later in the JSON', () => {
+    const text =
+      '{ "action": "steer", "confidence": 0.9, "reasoning": "Late reasoning", "message": "Hi" }';
+
+    expect(extractThinking(text)).toBe('Late reasoning');
+  });
+
+  it('returns empty string for empty input', () => {
+    expect(extractThinking('')).toBe('');
+  });
+});