brosh 0.2.2

package/packages/desktop-electron/tests/main/error-triage/parseTriageResponse.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+/**
+ * Tests for triage response parsing.
+ *
+ * parseTriageResponse is not exported directly, so we test it
+ * through the module's behavior by examining the expected parsing patterns.
+ */
+
+// Since parseTriageResponse is private, test the expected parsing patterns
+describe('Triage Response Parsing Patterns', () => {
+  describe('envelope format (claude --output-format json)', () => {
+    it('should parse standard envelope with result string', () => {
+      const envelope = {
+        result: '{"shouldNotify": true, "message": "Module not found: express"}',
+      };
+      const innerJson = envelope.result;
+      const parsed = JSON.parse(innerJson);
+
+      expect(parsed.shouldNotify).toBe(true);
+      expect(parsed.message).toBe('Module not found: express');
+    });
+
+    it('should handle direct format (no envelope)', () => {
+      const direct = {
+        shouldNotify: false,
+        message: '',
+      };
+
+      expect(typeof direct.shouldNotify).toBe('boolean');
+      expect(direct.shouldNotify).toBe(false);
+    });
+  });
+
+  describe('inner JSON parsing', () => {
+    it('should parse clean JSON', () => {
+      const json = '{"shouldNotify": true, "message": "Permission denied on /etc/config"}';
+      const parsed = JSON.parse(json);
+
+      expect(parsed.shouldNotify).toBe(true);
+      expect(parsed.message).toContain('Permission denied');
+    });
+
+    it('should handle markdown code fence wrapping', () => {
+      const wrapped = '```json\n{"shouldNotify": true, "message": "Syntax error"}\n```';
+      const cleaned = wrapped
+        .replace(/^```(?:json)?\s*\n?/, '')
+        .replace(/\n?```\s*$/, '');
+      const parsed = JSON.parse(cleaned);
+
+      expect(parsed.shouldNotify).toBe(true);
+      expect(parsed.message).toBe('Syntax error');
+    });
+
+    it('should handle code fence without language tag', () => {
+      const wrapped = '```\n{"shouldNotify": false, "message": ""}\n```';
+      const cleaned = wrapped
+        .replace(/^```(?:json)?\s*\n?/, '')
+        .replace(/\n?```\s*$/, '');
+      const parsed = JSON.parse(cleaned);
+
+      expect(parsed.shouldNotify).toBe(false);
+    });
+
+    it('should reject missing shouldNotify field', () => {
+      const json = '{"message": "some error"}';
+      const parsed = JSON.parse(json);
+
+      expect(typeof parsed.shouldNotify).not.toBe('boolean');
+    });
+
+    it('should handle empty message for shouldNotify=false', () => {
+      const json = '{"shouldNotify": false, "message": ""}';
+      const parsed = JSON.parse(json);
+
+      expect(parsed.shouldNotify).toBe(false);
+      expect(parsed.message).toBe('');
+    });
+  });
+
+  describe('error scenarios', () => {
+    it('should handle empty stdout', () => {
+      const trimmed = ''.trim();
+      expect(trimmed).toBe('');
+      // parseTriageResponse returns null for empty input
+    });
+
+    it('should handle malformed JSON', () => {
+      const malformed = '{"shouldNotify": true, message: broken}';
+      expect(() => JSON.parse(malformed)).toThrow();
+    });
+
+    it('should handle non-JSON responses', () => {
+      const text = 'The command failed because the module was not found.';
+      expect(() => JSON.parse(text)).toThrow();
+    });
+  });
+
+  describe('TriageResult contract', () => {
+    it('should always have boolean shouldNotify', () => {
+      const results = [
+        { shouldNotify: true, message: 'Error occurred' },
+        { shouldNotify: false, message: '' },
+      ];
+
+      for (const result of results) {
+        expect(typeof result.shouldNotify).toBe('boolean');
+        expect(typeof result.message).toBe('string');
+      }
+    });
+
+    it('should coerce message to string', () => {
+      // The actual code does String(parsed.message || "")
+      const coerce = (val: unknown) => String(val || '');
+
+      expect(coerce('hello')).toBe('hello');
+      expect(coerce(undefined)).toBe('');
+      expect(coerce(null)).toBe('');
+      expect(coerce('')).toBe('');
+      expect(coerce(42)).toBe('42');
+    });
+  });
+});

package/packages/desktop-electron/tests/main/terminal-bridge/battery-optimization.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+/**
+ * Tests for battery optimization features in terminal-bridge.
+ *
+ * These tests verify the state management logic for:
+ * - Window focus/blur handling
+ * - System suspend/resume handling
+ * - Spinner throttling when window is not focused
+ */
+
+describe('Battery Optimization', () => {
+  // Since TerminalBridge is tightly coupled to Electron's BrowserWindow,
+  // we test the state management logic by creating a minimal implementation
+  // that mirrors the actual behavior.
+
+  // Mock state that mirrors TerminalBridge internals
+  let windowFocused: boolean;
+  let systemSuspended: boolean;
+  let sessionAISpinner: Map<string, { timer: ReturnType<typeof setInterval>; frameIdx: number }>;
+  let sessionAIActive: Map<string, { cancel: () => void }>;
+  let startLoadingAnimationCalls: string[];
+  let clearedIntervals: ReturnType<typeof setInterval>[];
+
+  // Mock functions that mirror TerminalBridge methods
+  function setWindowFocused(focused: boolean): void {
+    windowFocused = focused;
+    if (!focused) {
+      // Pause AI spinners when window loses focus to save CPU
+      for (const spinner of sessionAISpinner.values()) {
+        clearInterval(spinner.timer);
+        clearedIntervals.push(spinner.timer);
+      }
+    } else if (!systemSuspended) {
+      // Resume spinners for active AI sessions when window regains focus
+      for (const sessionId of sessionAIActive.keys()) {
+        if (!sessionAISpinner.has(sessionId)) {
+          startLoadingAnimationCalls.push(sessionId);
+        }
+      }
+    }
+  }
+
+  function handleSystemSuspend(): void {
+    systemSuspended = true;
+    // Stop all AI spinners during system sleep
+    for (const spinner of sessionAISpinner.values()) {
+      clearInterval(spinner.timer);
+      clearedIntervals.push(spinner.timer);
+    }
+  }
+
+  function handleSystemResume(): void {
+    systemSuspended = false;
+    if (windowFocused) {
+      // Resume spinners for active AI sessions
+      for (const sessionId of sessionAIActive.keys()) {
+        if (!sessionAISpinner.has(sessionId)) {
+          startLoadingAnimationCalls.push(sessionId);
+        }
+      }
+    }
+  }
+
+  beforeEach(() => {
+    windowFocused = true;
+    systemSuspended = false;
+    sessionAISpinner = new Map();
+    sessionAIActive = new Map();
+    startLoadingAnimationCalls = [];
+    clearedIntervals = [];
+  });
+
+  describe('setWindowFocused', () => {
+    it('should update windowFocused state to true', () => {
+      windowFocused = false;
+      setWindowFocused(true);
+      expect(windowFocused).toBe(true);
+    });
+
+    it('should update windowFocused state to false', () => {
+      windowFocused = true;
+      setWindowFocused(false);
+      expect(windowFocused).toBe(false);
+    });
+
+    it('should clear all spinner intervals when window loses focus', () => {
+      // Set up active spinners
+      const timer1 = setInterval(() => {}, 1000);
+      const timer2 = setInterval(() => {}, 1000);
+      sessionAISpinner.set('session-1', { timer: timer1, frameIdx: 0 });
+      sessionAISpinner.set('session-2', { timer: timer2, frameIdx: 0 });
+
+      setWindowFocused(false);
+
+      expect(clearedIntervals).toContain(timer1);
+      expect(clearedIntervals).toContain(timer2);
+
+      // Clean up
+      clearInterval(timer1);
+      clearInterval(timer2);
+    });
+
+    it('should restart spinners for active AI sessions when window regains focus', () => {
+      windowFocused = false;
+      sessionAIActive.set('session-1', { cancel: () => {} });
+      sessionAIActive.set('session-2', { cancel: () => {} });
+
+      setWindowFocused(true);
+
+      expect(startLoadingAnimationCalls).toContain('session-1');
+      expect(startLoadingAnimationCalls).toContain('session-2');
+    });
+
+    it('should not restart spinners if system is suspended', () => {
+      windowFocused = false;
+      systemSuspended = true;
+      sessionAIActive.set('session-1', { cancel: () => {} });
+
+      setWindowFocused(true);
+
+      expect(startLoadingAnimationCalls).toHaveLength(0);
+    });
+
+    it('should not restart spinners that already exist', () => {
+      windowFocused = false;
+      sessionAIActive.set('session-1', { cancel: () => {} });
+      const timer = setInterval(() => {}, 1000);
+      sessionAISpinner.set('session-1', { timer, frameIdx: 0 });
+
+      setWindowFocused(true);
+
+      expect(startLoadingAnimationCalls).not.toContain('session-1');
+
+      // Clean up
+      clearInterval(timer);
+    });
+  });
+
+  describe('handleSystemSuspend', () => {
+    it('should set systemSuspended to true', () => {
+      expect(systemSuspended).toBe(false);
+      handleSystemSuspend();
+      expect(systemSuspended).toBe(true);
+    });
+
+    it('should clear all spinner intervals', () => {
+      const timer1 = setInterval(() => {}, 1000);
+      const timer2 = setInterval(() => {}, 1000);
+      sessionAISpinner.set('session-1', { timer: timer1, frameIdx: 0 });
+      sessionAISpinner.set('session-2', { timer: timer2, frameIdx: 0 });
+
+      handleSystemSuspend();
+
+      expect(clearedIntervals).toContain(timer1);
+      expect(clearedIntervals).toContain(timer2);
+
+      // Clean up
+      clearInterval(timer1);
+      clearInterval(timer2);
+    });
+  });
+
+  describe('handleSystemResume', () => {
+    it('should set systemSuspended to false', () => {
+      systemSuspended = true;
+      handleSystemResume();
+      expect(systemSuspended).toBe(false);
+    });
+
+    it('should restart spinners for active sessions when window is focused', () => {
+      systemSuspended = true;
+      windowFocused = true;
+      sessionAIActive.set('session-1', { cancel: () => {} });
+      sessionAIActive.set('session-2', { cancel: () => {} });
+
+      handleSystemResume();
+
+      expect(startLoadingAnimationCalls).toContain('session-1');
+      expect(startLoadingAnimationCalls).toContain('session-2');
+    });
+
+    it('should not restart spinners when window is not focused', () => {
+      systemSuspended = true;
+      windowFocused = false;
+      sessionAIActive.set('session-1', { cancel: () => {} });
+
+      handleSystemResume();
+
+      expect(startLoadingAnimationCalls).toHaveLength(0);
+    });
+
+    it('should not restart spinners that already exist', () => {
+      systemSuspended = true;
+      windowFocused = true;
+      sessionAIActive.set('session-1', { cancel: () => {} });
+      const timer = setInterval(() => {}, 1000);
+      sessionAISpinner.set('session-1', { timer, frameIdx: 0 });
+
+      handleSystemResume();
+
+      expect(startLoadingAnimationCalls).not.toContain('session-1');
+
+      // Clean up
+      clearInterval(timer);
+    });
+  });
+
+  describe('interaction between focus and suspend states', () => {
+    it('should not restart spinners when resuming from sleep if window was blurred', () => {
+      // Simulate: window blurred -> system sleeps -> system wakes
+      windowFocused = true;
+      sessionAIActive.set('session-1', { cancel: () => {} });
+
+      // Window loses focus
+      setWindowFocused(false);
+      startLoadingAnimationCalls = [];
+
+      // System goes to sleep
+      handleSystemSuspend();
+
+      // System wakes up (window still not focused)
+      handleSystemResume();
+
+      expect(startLoadingAnimationCalls).toHaveLength(0);
+    });
+
+    it('should restart spinners when window is focused after wake', () => {
+      // Simulate: system sleeps -> system wakes -> window focused
+      systemSuspended = true;
+      windowFocused = false;
+      sessionAIActive.set('session-1', { cancel: () => {} });
+
+      // System wakes up
+      handleSystemResume();
+      expect(startLoadingAnimationCalls).toHaveLength(0);
+
+      // Window gets focus
+      setWindowFocused(true);
+      expect(startLoadingAnimationCalls).toContain('session-1');
+    });
+  });
+});

package/packages/desktop-electron/tests/main/terminal-bridge/command-fast-track.test.ts

@@ -0,0 +1,292 @@
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import {
+  classifyInput,
+  isKnownCommand,
+  initializeDetection,
+} from '../../../src/main/ai-detection.js';
+
+/**
+ * Tests for command-first input classification and retroactive NL detection.
+ *
+ * The fast-track flow:
+ *   Enter → denylist → isKnownCommand? → YES → shell (skip ML)
+ *                                       → NO  → ML classifier
+ *
+ * When a fast-tracked command fails (non-zero exit):
+ *   Re-classify with ML → NL? → invoke AI retroactively
+ *                       → CMD? → normal error triage
+ */
+
+describe('Command Fast-Track Classification', () => {
+  beforeAll(async () => {
+    await initializeDetection({ preloadML: true });
+  });
+
+  describe('isKnownCommand', () => {
+    it('should recognize common Unix commands', () => {
+      const knownCommands = ['ls', 'cd', 'cat', 'grep', 'find', 'mkdir', 'rm', 'cp', 'mv', 'chmod'];
+      for (const cmd of knownCommands) {
+        expect(isKnownCommand(cmd)).toBe(true);
+      }
+    });
+
+    it('should recognize package managers', () => {
+      const packageManagers = ['npm', 'yarn', 'pip', 'brew', 'cargo'];
+      for (const cmd of packageManagers) {
+        expect(isKnownCommand(cmd)).toBe(true);
+      }
+    });
+
+    it('should recognize language runtimes', () => {
+      const runtimes = ['node', 'python', 'ruby', 'java', 'go'];
+      for (const cmd of runtimes) {
+        expect(isKnownCommand(cmd)).toBe(true);
+      }
+    });
+
+    it('should recognize version control tools', () => {
+      expect(isKnownCommand('git')).toBe(true);
+    });
+
+    it('should recognize container tools', () => {
+      const containers = ['docker', 'kubectl'];
+      for (const cmd of containers) {
+        expect(isKnownCommand(cmd)).toBe(true);
+      }
+    });
+
+    it('should NOT recognize natural language words', () => {
+      const nlWords = ['how', 'what', 'list', 'show', 'explain', 'help', 'create', 'delete'];
+      for (const word of nlWords) {
+        // Some of these might happen to be commands (like 'help')
+        // but most NL starter words should not be known commands
+        if (word === 'help') continue; // shell builtin
+        expect(isKnownCommand(word)).toBe(false);
+      }
+    });
+
+    it('should NOT recognize gibberish', () => {
+      expect(isKnownCommand('asdfgh')).toBe(false);
+      expect(isKnownCommand('xyzzy')).toBe(false);
+      expect(isKnownCommand('foobar123')).toBe(false);
+    });
+
+    it('should be case-sensitive (commands are lowercase)', () => {
+      // isKnownCommand expects lowercase input (caller normalizes)
+      expect(isKnownCommand('ls')).toBe(true);
+      expect(isKnownCommand('node')).toBe(true);
+    });
+  });
+
+  describe('fast-track decision logic', () => {
+    // Mirrors the logic in terminal-bridge.ts handleInputWithAIDetection:
+    // 1. Extract firstWord from trimmedLine
+    // 2. If isKnownCommand(firstWord) → skip ML, send to shell
+    // 3. Else → run ML classifyInput
+
+    function shouldFastTrack(input: string): boolean {
+      const trimmed = input.trim();
+      if (!trimmed) return false;
+      const firstWord = trimmed.split(/\s+/)[0].toLowerCase();
+      return isKnownCommand(firstWord);
+    }
+
+    it('should fast-track simple commands', () => {
+      expect(shouldFastTrack('ls')).toBe(true);
+      expect(shouldFastTrack('ls -la')).toBe(true);
+      expect(shouldFastTrack('git status')).toBe(true);
+      expect(shouldFastTrack('npm install')).toBe(true);
+      expect(shouldFastTrack('docker ps')).toBe(true);
+    });
+
+    it('should fast-track commands where first word is a known command', () => {
+      // Even if the rest looks like NL, fast-track based on first word
+      expect(shouldFastTrack('node has how many letters')).toBe(true);
+      expect(shouldFastTrack('python is a great language')).toBe(true);
+      expect(shouldFastTrack('git is version control')).toBe(true);
+    });
+
+    it('should NOT fast-track natural language', () => {
+      expect(shouldFastTrack('list all files')).toBe(false);
+      expect(shouldFastTrack('show me the logs')).toBe(false);
+      expect(shouldFastTrack('how do I install node')).toBe(false);
+      expect(shouldFastTrack('what is my ip address')).toBe(false);
+    });
+
+    it('should NOT fast-track unknown first words', () => {
+      expect(shouldFastTrack('thisis a prompt')).toBe(false);
+      expect(shouldFastTrack('asdfgh')).toBe(false);
+      expect(shouldFastTrack('please run the tests')).toBe(false);
+    });
+
+    it('should NOT fast-track empty input', () => {
+      expect(shouldFastTrack('')).toBe(false);
+      expect(shouldFastTrack('   ')).toBe(false);
+    });
+  });
+
+  describe('retroactive ML re-classification', () => {
+    // When a fast-tracked command fails, we re-classify with ML.
+    // If ML says NL with high confidence → invoke AI
+    // If ML says CMD → normal error handling
+
+    it('should re-classify "node has how many letters" as NL', async () => {
+      // First word is known (node), so it gets fast-tracked
+      expect(isKnownCommand('node')).toBe(true);
+
+      // But ML should classify the full input as NL
+      const result = await classifyInput('node has how many letters');
+      // The mock ML classifier should see this as a question-like statement
+      // The actual ML model classifies this as NL with high confidence
+      // With the mock, this depends on the heuristics in setup.ts
+      expect(result).toHaveProperty('classification');
+      expect(result).toHaveProperty('confidence');
+    });
+
+    it('should re-classify "node -e require(missing)" as CMD', async () => {
+      expect(isKnownCommand('node')).toBe(true);
+
+      // This is a real command that happened to fail
+      const result = await classifyInput('node -e "require(\'missing\')"');
+      expect(result.classification).toBe('COMMAND');
+    });
+
+    it('should re-classify "git is version control" as NL', async () => {
+      expect(isKnownCommand('git')).toBe(true);
+
+      // NL starting with a known command
+      const result = await classifyInput('git is version control');
+      // This should be classified based on ML heuristics
+      expect(result).toHaveProperty('classification');
+    });
+
+    it('should re-classify real commands with flags as CMD', async () => {
+      const realCommands = [
+        'node --version',
+        'node -e "console.log(1)"',
+        'python -m pytest',
+        'git log --oneline',
+        'npm run build',
+      ];
+      for (const cmd of realCommands) {
+        const result = await classifyInput(cmd);
+        expect(result.classification).toBe('COMMAND');
+      }
+    });
+  });
+
+  describe('fast-track state management', () => {
+    // Mirrors sessionFastTracked / sessionFastTrackLines Map behavior
+
+    it('should track fast-track state per session', () => {
+      const sessionFastTracked = new Map<string, boolean>();
+      const sessionFastTrackLines = new Map<string, number>();
+
+      // Session 1: fast-tracked command
+      sessionFastTracked.set('session-1', true);
+      sessionFastTrackLines.set('session-1', 0);
+
+      // Session 2: ML-classified command
+      sessionFastTracked.set('session-2', false);
+
+      expect(sessionFastTracked.get('session-1')).toBe(true);
+      expect(sessionFastTracked.get('session-2')).toBe(false);
+      expect(sessionFastTrackLines.get('session-1')).toBe(0);
+    });
+
+    it('should count output lines for fast-tracked commands', () => {
+      const sessionFastTrackLines = new Map<string, number>();
+      sessionFastTrackLines.set('session-1', 0);
+
+      // Simulate PTY output chunks with newlines
+      function countNewlines(data: string, sessionId: string) {
+        const lines = sessionFastTrackLines.get(sessionId) || 0;
+        let newlines = 0;
+        for (let i = 0; i < data.length; i++) {
+          if (data[i] === '\n') newlines++;
+        }
+        if (newlines > 0) {
+          sessionFastTrackLines.set(sessionId, lines + newlines);
+        }
+      }
+
+      countNewlines('\r\n', 'session-1'); // Enter echo
+      countNewlines('error line 1\r\n', 'session-1');
+      countNewlines('error line 2\r\n', 'session-1');
+      countNewlines('error line 3\r\n', 'session-1');
+
+      expect(sessionFastTrackLines.get('session-1')).toBe(4);
+    });
+
+    it('should calculate correct erase line count', () => {
+      // outputLines includes the Enter-echo \n, so -1 to preserve original prompt
+      const outputLines = 19; // e.g., 1 (enter echo) + 18 (error output)
+      const linesToErase = outputLines - 1;
+      expect(linesToErase).toBe(18);
+
+      // Edge case: only Enter echo, no error output
+      const minOutputLines = 1;
+      const minErase = minOutputLines - 1;
+      expect(minErase).toBe(0);
+    });
+
+    it('should not erase when outputLines <= 1', () => {
+      // Guard condition from handleFailedFastTrack
+      const shouldErase = (outputLines: number) => outputLines > 1;
+
+      expect(shouldErase(0)).toBe(false);
+      expect(shouldErase(1)).toBe(false);
+      expect(shouldErase(2)).toBe(true);
+      expect(shouldErase(19)).toBe(true);
+    });
+
+    it('should generate correct escape sequence for erasure', () => {
+      const outputLines = 19;
+      const linesToErase = outputLines - 1;
+      const escapeSeq = `\r\x1b[${linesToErase}A\x1b[J`;
+
+      // \r moves to column 0 (fixes partial line remnant)
+      expect(escapeSeq).toContain('\r');
+      // \x1b[18A moves cursor up 18 lines
+      expect(escapeSeq).toContain('\x1b[18A');
+      // \x1b[J clears from cursor to end of screen
+      expect(escapeSeq).toContain('\x1b[J');
+    });
+
+    it('should clean up state on session close', () => {
+      const sessionFastTracked = new Map<string, boolean>();
+      const sessionFastTrackLines = new Map<string, number>();
+
+      sessionFastTracked.set('session-1', true);
+      sessionFastTrackLines.set('session-1', 15);
+
+      // Simulate closeSession cleanup
+      sessionFastTracked.delete('session-1');
+      sessionFastTrackLines.delete('session-1');
+
+      expect(sessionFastTracked.has('session-1')).toBe(false);
+      expect(sessionFastTrackLines.has('session-1')).toBe(false);
+    });
+  });
+
+  describe('edge cases from plan', () => {
+    // Test cases from the implementation plan's edge case table
+
+    it('clear → fast-tracked, exits 0, no retroactive check', () => {
+      expect(isKnownCommand('clear')).toBe(true);
+      // exit 0 → no retroactive ML check needed
+    });
+
+    it('node --help → fast-tracked, exits 0', () => {
+      expect(isKnownCommand('node')).toBe(true);
+    });
+
+    it('"list all files" → NOT fast-tracked, goes to ML', () => {
+      expect(isKnownCommand('list')).toBe(false);
+    });
+
+    it('"thisis a prompt" → NOT fast-tracked, goes to ML', () => {
+      expect(isKnownCommand('thisis')).toBe(false);
+    });
+  });
+});