chore: fix linting errors

Author: sebastianstupak

src/features/chat/components/AttachmentsArea.tsx

@@ -64,12 +64,8 @@ export const AttachmentsArea: React.FC<AttachmentsAreaProps> = ({
       });
   }, [attachments, provider, model]);
 
-  // Don't render if no attachments
-  if (attachmentList.length === 0) {
-    return null;
-  }
-
   // Build footer text with keyboard shortcuts
+  // NOTE: This hook must be called before any early return to maintain consistent hook count
   const footerText = useMemo(() => {
     return buildFooterText([
       { shortcut: keyBindings.navigateLeft, label: 'prev' },
@@ -78,6 +74,11 @@ export const AttachmentsArea: React.FC<AttachmentsAreaProps> = ({
     ]);
   }, [keyBindings]);
 
+  // Don't render if no attachments
+  if (attachmentList.length === 0) {
+    return null;
+  }
+
   // Determine if we need scroll indicators
   const maxVisibleItems = 3; // Max items to show before scrolling
   const needsScrolling = attachmentList.length > maxVisibleItems;

src/shared/utils/bracketedPaste.ts

@@ -139,7 +139,10 @@ export function detectPasteHeuristic(newValue: string, oldValue: string): boolea
  * @returns Input with paste markers removed
  */
 export function stripBracketedPasteMarkers(input: string): string {
-  return input.replace(new RegExp(`${PASTE_START}|${PASTE_END}`, 'g'), '');
+  // Escape the special regex characters in the paste markers
+  const escapeRegex = (str: string) => str.replace(/[[\]\\]/g, '\\$&');
+  const pattern = `${escapeRegex(PASTE_START)}|${escapeRegex(PASTE_END)}`;
+  return input.replace(new RegExp(pattern, 'g'), '');
 }
 
 /**

tests/unit/cli/components/InputBox.test.tsx

@@ -330,7 +330,7 @@ describe('InputBox Autocomplete Logic', () => {
 
       expect(state.showAutocomplete).toBe(true);
       expect(state.isParameterMode).toBe(true);
-      expect(state.parameterSuggestions).toHaveLength(10); // Updated: now have 10 providers
+      expect(state.parameterSuggestions).toHaveLength(11); // Updated: now have 11 providers
       expect(state.parameterSuggestions).toContain('deepseek');
       expect(state.parameterSuggestions).toContain('anthropic');
       expect(state.parameterSuggestions).toContain('openai');

tests/unit/cli/keyboard/KeyboardEventBus.test.ts

@@ -368,10 +368,11 @@ describe('KeyboardEventBus', () => {
         expect(eventBus.isActionRelevantInContext('interrupt')).toBe(true);
       });
 
-      it('should NOT be relevant when agent is not running', () => {
+      it('should always be relevant (can exit app when not running, interrupt when running)', () => {
         eventBus.updateContext({ isAgentRunning: false });
 
-        expect(eventBus.isActionRelevantInContext('interrupt')).toBe(false);
+        // interrupt is always relevant - exits app when not running, interrupts agent when running
+        expect(eventBus.isActionRelevantInContext('interrupt')).toBe(true);
       });
     });
 

tests/unit/core/PermissionManager.test.ts

@@ -2,45 +2,155 @@
  * Unit tests for PermissionManager
  */
 
-import { describe, it, expect, beforeEach } from 'vitest';
-import { PermissionManager } from '@/features/permissions/manager/PermissionManager.js';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { PermissionManager } from '@codedir/mimir-agents';
+import type {
+  PermissionManagerConfig,
+  PermissionRequest,
+  IAuditLogger,
+  AuditLogEntry,
+} from '@codedir/mimir-agents';
 
 describe('PermissionManager', () => {
   let manager: PermissionManager;
+  let auditLog: AuditLogEntry[];
+  let mockAuditLogger: IAuditLogger;
 
   beforeEach(() => {
-    manager = new PermissionManager();
+    auditLog = [];
+    mockAuditLogger = {
+      log: vi.fn(async (entry: AuditLogEntry) => {
+        auditLog.push(entry);
+      }),
+    };
+
+    const config: PermissionManagerConfig = {
+      allowlist: [],
+      blocklist: [],
+      acceptRiskLevel: 'low',
+      autoAccept: true,
+      auditLogger: mockAuditLogger,
+    };
+    manager = new PermissionManager(config);
   });
 
   it('should allow low risk commands by default', async () => {
-    const result = await manager.checkPermission('ls -la');
+    const request: PermissionRequest = { type: 'bash', command: 'ls -la' };
+    const result = await manager.checkPermission(request);
     expect(result.allowed).toBe(true);
   });
 
   it('should deny high risk commands by default', async () => {
-    const result = await manager.checkPermission('rm -rf /');
+    const request: PermissionRequest = { type: 'bash', command: 'rm -rf /' };
+    const result = await manager.checkPermission(request);
     expect(result.allowed).toBe(false);
   });
 
   it('should respect allowlist', async () => {
-    manager.addToAllowlist('rm -rf node_modules');
-    const result = await manager.checkPermission('rm -rf node_modules');
+    const config: PermissionManagerConfig = {
+      allowlist: ['rm -rf node_modules'],
+      blocklist: [],
+      acceptRiskLevel: 'low',
+      autoAccept: true,
+      auditLogger: mockAuditLogger,
+    };
+    const managerWithAllowlist = new PermissionManager(config);
+
+    const request: PermissionRequest = { type: 'bash', command: 'rm -rf node_modules' };
+    const result = await managerWithAllowlist.checkPermission(request);
     expect(result.allowed).toBe(true);
   });
 
   it('should respect blocklist', async () => {
-    manager.addToBlocklist('git push');
-    const result = await manager.checkPermission('git push');
+    const config: PermissionManagerConfig = {
+      allowlist: [],
+      blocklist: ['git push'],
+      acceptRiskLevel: 'high', // Allow high risk, but blocklist takes priority
+      autoAccept: true,
+      auditLogger: mockAuditLogger,
+    };
+    const managerWithBlocklist = new PermissionManager(config);
+
+    const request: PermissionRequest = { type: 'bash', command: 'git push' };
+    const result = await managerWithBlocklist.checkPermission(request);
     expect(result.allowed).toBe(false);
   });
 
   it('should maintain audit log', async () => {
-    await manager.checkPermission('ls -la');
-    await manager.checkPermission('rm -rf /');
+    const request1: PermissionRequest = { type: 'bash', command: 'ls -la' };
+    const request2: PermissionRequest = { type: 'bash', command: 'rm -rf /' };
+
+    await manager.checkPermission(request1);
+    await manager.checkPermission(request2);
+
+    expect(auditLog).toHaveLength(2);
+    expect(auditLog[0]?.operation).toBe('ls -la');
+    expect(auditLog[1]?.operation).toBe('rm -rf /');
+  });
+
+  describe('risk level acceptance', () => {
+    it('should auto-accept commands at or below accept risk level', async () => {
+      const config: PermissionManagerConfig = {
+        allowlist: [],
+        blocklist: [],
+        acceptRiskLevel: 'medium',
+        autoAccept: true,
+      };
+      const managerMedium = new PermissionManager(config);
+
+      // Low risk - should be accepted
+      const lowRisk: PermissionRequest = { type: 'bash', command: 'ls -la' };
+      const lowResult = await managerMedium.checkPermission(lowRisk);
+      expect(lowResult.allowed).toBe(true);
+
+      // Medium risk (npm install) - should be accepted
+      const mediumRisk: PermissionRequest = { type: 'bash', command: 'npm install express' };
+      const mediumResult = await managerMedium.checkPermission(mediumRisk);
+      expect(mediumResult.allowed).toBe(true);
+    });
+
+    it('should deny commands above accept risk level', async () => {
+      const config: PermissionManagerConfig = {
+        allowlist: [],
+        blocklist: [],
+        acceptRiskLevel: 'low',
+        autoAccept: true,
+      };
+      const managerLow = new PermissionManager(config);
+
+      // High risk - should be denied
+      const highRisk: PermissionRequest = { type: 'bash', command: 'rm -rf ./node_modules' };
+      const highResult = await managerLow.checkPermission(highRisk);
+      expect(highResult.allowed).toBe(false);
+    });
+
+    it('should deny all when autoAccept is false', async () => {
+      const config: PermissionManagerConfig = {
+        allowlist: [],
+        blocklist: [],
+        acceptRiskLevel: 'critical', // Even with high accept level
+        autoAccept: false, // Auto-accept disabled
+      };
+      const managerNoAuto = new PermissionManager(config);
+
+      const lowRisk: PermissionRequest = { type: 'bash', command: 'ls -la' };
+      const result = await managerNoAuto.checkPermission(lowRisk);
+      expect(result.allowed).toBe(false);
+    });
+  });
+
+  describe('file operations', () => {
+    it('should handle file read requests', async () => {
+      const request: PermissionRequest = { type: 'file_read', path: '/etc/passwd' };
+      const result = await manager.checkPermission(request);
+      // Low risk file read with low accept level should be allowed
+      expect(result.riskLevel).toBeDefined();
+    });
 
-    const log = manager.getAuditLog();
-    expect(log).toHaveLength(2);
-    expect(log[0]?.command).toBe('ls -la');
-    expect(log[1]?.command).toBe('rm -rf /');
+    it('should handle file write requests', async () => {
+      const request: PermissionRequest = { type: 'file_write', path: './output.txt' };
+      const result = await manager.checkPermission(request);
+      expect(result.riskLevel).toBeDefined();
+    });
   });
 });

tests/unit/core/RiskAssessor.test.ts

@@ -3,7 +3,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { RiskAssessor } from '@/features/permissions/assessor/RiskAssessor.js';
+import { RiskAssessor } from '@codedir/mimir-agents';
 
 describe('RiskAssessor', () => {
   const assessor = new RiskAssessor();

tests/unit/features/chat/utils/AttachmentManager.test.ts

@@ -321,14 +321,14 @@ describe('AttachmentManager', () => {
   describe('expandForAPI', () => {
     it('should handle empty message and no attachments', () => {
       const result = manager.expandForAPI('');
-      expect(result.content).toEqual([]);
+      expect(result).toEqual([]);
     });
 
     it('should include message text only', () => {
       const result = manager.expandForAPI('Hello, world!');
 
-      expect(result.content).toHaveLength(1);
-      expect(result.content[0]).toEqual({
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
         type: 'text',
         text: 'Hello, world!',
       });
@@ -344,12 +344,12 @@ describe('AttachmentManager', () => {
       manager.addTextAttachment('Pasted content', metadata);
       const result = manager.expandForAPI('Main message');
 
-      expect(result.content).toHaveLength(2);
-      expect(result.content[0].type).toBe('text');
-      expect(result.content[0].text).toBe('Main message');
-      expect(result.content[1].type).toBe('text');
-      expect(result.content[1].text).toContain('[Pasted text #1]');
-      expect(result.content[1].text).toContain('Pasted content');
+      expect(result).toHaveLength(2);
+      expect(result[0].type).toBe('text');
+      expect((result[0] as { type: 'text'; text: string }).text).toBe('Main message');
+      expect(result[1].type).toBe('text');
+      expect((result[1] as { type: 'text'; text: string }).text).toContain('[Pasted text #1]');
+      expect((result[1] as { type: 'text'; text: string }).text).toContain('Pasted content');
     });
 
     it('should expand image attachments as base64', () => {
@@ -358,13 +358,11 @@ describe('AttachmentManager', () => {
 
       const result = manager.expandForAPI('Check this image');
 
-      expect(result.content).toHaveLength(2);
-      expect(result.content[1].type).toBe('image');
-      expect(result.content[1].source).toEqual({
-        type: 'base64',
-        media_type: 'image/png',
-        data: imageData.toString('base64'),
-      });
+      expect(result).toHaveLength(2);
+      expect(result[1].type).toBe('image_url');
+      expect((result[1] as { type: 'image_url'; image_url: { url: string } }).image_url.url).toBe(
+        `data:image/png;base64,${imageData.toString('base64')}`
+      );
     });
 
     it('should handle mixed text and image attachments', () => {
@@ -381,12 +379,12 @@ describe('AttachmentManager', () => {
 
       const result = manager.expandForAPI('Message');
 
-      expect(result.content).toHaveLength(5); // 1 message + 4 attachments
-      expect(result.content[0].type).toBe('text'); // Main message
-      expect(result.content[1].type).toBe('text'); // Text paste
-      expect(result.content[2].type).toBe('image'); // Image 1
-      expect(result.content[3].type).toBe('text'); // More text
-      expect(result.content[4].type).toBe('image'); // Image 2
+      expect(result).toHaveLength(5); // 1 message + 4 attachments
+      expect(result[0].type).toBe('text'); // Main message
+      expect(result[1].type).toBe('text'); // Text paste
+      expect(result[2].type).toBe('image_url'); // Image 1
+      expect(result[3].type).toBe('text'); // More text
+      expect(result[4].type).toBe('image_url'); // Image 2
     });
 
     it('should preserve attachment order by creation time', () => {
@@ -402,10 +400,10 @@ describe('AttachmentManager', () => {
 
       const result = manager.expandForAPI('');
 
-      expect(result.content).toHaveLength(3);
-      expect(result.content[0].text).toContain('First');
-      expect(result.content[1].text).toContain('Second');
-      expect(result.content[2].text).toContain('Third');
+      expect(result).toHaveLength(3);
+      expect((result[0] as { type: 'text'; text: string }).text).toContain('First');
+      expect((result[1] as { type: 'text'; text: string }).text).toContain('Second');
+      expect((result[2] as { type: 'text'; text: string }).text).toContain('Third');
     });
   });
 

tests/unit/shared/utils/CredentialsManager.test.ts

@@ -3,14 +3,15 @@
  */
 
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { CredentialsManager, type StorageLocation } from '@/shared/utils/CredentialsManager.js';
 import { promises as fs } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
-import * as keytar from 'keytar';
 
-// Test home directory path - defined before mock
-const testHomedir = join(tmpdir(), 'mimir-test-home');
+// Use vi.hoisted to define testHomedir BEFORE mocks are processed
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const testHomedir = vi.hoisted(() =>
+  require('path').join(require('os').tmpdir(), 'mimir-test-home')
+);
 
 // Mock keytar
 vi.mock('keytar', () => ({
@@ -29,6 +30,10 @@ vi.mock('os', async () => {
   };
 });
 
+// Import after mocks are set up
+import { CredentialsManager, type StorageLocation } from '@/shared/utils/CredentialsManager.js';
+import * as keytar from 'keytar';
+
 describe('CredentialsManager', () => {
   let credentialsManager: CredentialsManager;
   let testDir: string;

tests/unit/shared/utils/bracketedPaste.test.ts

@@ -213,7 +213,7 @@ describe('Bracketed Paste Utilities', () => {
 
     it('should detect 11 char delta as paste', () => {
       const oldValue = 'Hello';
-      const newValue = 'Hello123456'; // +11 chars
+      const newValue = 'Hello12345678901'; // +11 chars (16 - 5 = 11)
       expect(detectPasteHeuristic(newValue, oldValue)).toBe(true);
     });