markupr 2.1.8

package/tests/unit/tierManagerExpanded.test.ts

@@ -0,0 +1,142 @@
+/**
+ * TierManager Expanded Tests
+ *
+ * Extends the basic 4 tests with:
+ * - Failover chain behavior (whisper -> timer-only)
+ * - Timer-only emergency mode
+ * - Tier quality metadata
+ * - hasTranscriptionCapability checks
+ * - Edge cases
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import { TierManager } from '../../src/main/transcription/TierManager';
+import type { TierStatus } from '../../src/main/transcription/types';
+
+function makeStatuses(
+  overrides: Partial<Record<TierStatus['tier'], Partial<TierStatus>>>
+): TierStatus[] {
+  const defaults: TierStatus[] = [
+    { tier: 'whisper', available: false, reason: 'Model not downloaded' },
+    { tier: 'timer-only', available: true },
+  ];
+
+  return defaults.map((status) => ({
+    ...status,
+    ...(overrides[status.tier] ?? {}),
+  }));
+}
+
+describe('TierManager failover chain', () => {
+  it('falls through to timer-only when whisper is unavailable', async () => {
+    const manager = new TierManager();
+    vi.spyOn(manager, 'getTierStatuses').mockResolvedValue(
+      makeStatuses({
+        whisper: { tier: 'whisper', available: false, reason: 'No model' },
+      })
+    );
+
+    const selected = await manager.selectBestTier();
+    expect(selected).toBe('timer-only');
+  });
+
+  it('prefers Whisper in auto mode when available', async () => {
+    const manager = new TierManager();
+    vi.spyOn(manager, 'getTierStatuses').mockResolvedValue(
+      makeStatuses({
+        whisper: { tier: 'whisper', available: true },
+      })
+    );
+
+    const selected = await manager.selectBestTier();
+    expect(selected).toBe('whisper');
+  });
+
+  it('selects Whisper when only Whisper is available', async () => {
+    const manager = new TierManager();
+    vi.spyOn(manager, 'getTierStatuses').mockResolvedValue(
+      makeStatuses({
+        whisper: { tier: 'whisper', available: true },
+      })
+    );
+
+    const selected = await manager.selectBestTier();
+    expect(selected).toBe('whisper');
+  });
+});
+
+describe('TierManager preference edge cases', () => {
+  it('rejects timer-only as preferred tier', () => {
+    const manager = new TierManager();
+    expect(() => manager.setPreferredTier('timer-only')).toThrow(
+      'does not provide transcription'
+    );
+  });
+
+  it('accepts auto as preferred tier', () => {
+    const manager = new TierManager();
+    expect(() => manager.setPreferredTier('auto')).not.toThrow();
+  });
+
+  it('accepts whisper as preferred tier', () => {
+    const manager = new TierManager();
+    expect(() => manager.setPreferredTier('whisper')).not.toThrow();
+  });
+});
+
+describe('TierManager hasTranscriptionCapability', () => {
+  it('returns true when Whisper is available', async () => {
+    const manager = new TierManager();
+    vi.spyOn(manager, 'getTierStatuses').mockResolvedValue(
+      makeStatuses({
+        whisper: { tier: 'whisper', available: true },
+      })
+    );
+
+    const hasCap = await manager.hasTranscriptionCapability();
+    expect(hasCap).toBe(true);
+  });
+
+  it('returns false when only timer-only is available and no OpenAI key', async () => {
+    const manager = new TierManager();
+    vi.spyOn(manager, 'getTierStatuses').mockResolvedValue(
+      makeStatuses({
+        whisper: { tier: 'whisper', available: false },
+        'timer-only': { tier: 'timer-only', available: true },
+      })
+    );
+
+    const hasCap = await manager.hasTranscriptionCapability();
+    expect(hasCap).toBe(false);
+  });
+});
+
+describe('TierManager status reporting', () => {
+  it('returns all 2 tier statuses', async () => {
+    const manager = new TierManager();
+    vi.spyOn(manager, 'getTierStatuses').mockResolvedValue(
+      makeStatuses({})
+    );
+
+    const statuses = await manager.getTierStatuses();
+    expect(statuses).toHaveLength(2);
+
+    const tiers = statuses.map((s) => s.tier);
+    expect(tiers).toContain('whisper');
+    expect(tiers).toContain('timer-only');
+  });
+
+  it('includes availability reason when tier is unavailable', async () => {
+    const manager = new TierManager();
+    vi.spyOn(manager, 'getTierStatuses').mockResolvedValue(
+      makeStatuses({
+        whisper: { tier: 'whisper', available: false, reason: 'Model not downloaded' },
+      })
+    );
+
+    const statuses = await manager.getTierStatuses();
+    const whisper = statuses.find((s) => s.tier === 'whisper');
+    expect(whisper?.available).toBe(false);
+    expect(whisper?.reason).toBe('Model not downloaded');
+  });
+});

package/tests/unit/transcriptAnalyzer.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+import { TranscriptAnalyzer, type KeyMoment } from '../../src/main/pipeline/TranscriptAnalyzer';
+import type { TranscriptSegment } from '../../src/main/pipeline/PostProcessor';
+
+function makeSegments(): TranscriptSegment[] {
+  return [
+    { text: 'Start feedback', startTime: 0, endTime: 2, confidence: 0.9 },
+    { text: 'More context', startTime: 4, endTime: 7, confidence: 0.9 },
+  ];
+}
+
+describe('TranscriptAnalyzer', () => {
+  it('adds periodic captures only when no AI hints are present', () => {
+    const analyzer = new TranscriptAnalyzer();
+    const segments: TranscriptSegment[] = [
+      { text: 'session start', startTime: 0, endTime: 10, confidence: 0.9 },
+      { text: 'session end', startTime: 11, endTime: 30, confidence: 0.9 },
+    ];
+
+    const withoutHints = analyzer.analyze(segments, []);
+    const withHints = analyzer.analyze(segments, [
+      { timestamp: 30, reason: 'AI-highlighted context', confidence: 0.9 },
+    ]);
+
+    expect(withoutHints.some((moment) => moment.reason === 'Periodic capture')).toBe(true);
+    expect(withHints.some((moment) => moment.reason === 'Periodic capture')).toBe(false);
+  });
+
+  it('keeps AI hint when it overlaps a periodic candidate', () => {
+    const analyzer = new TranscriptAnalyzer();
+    const moments = analyzer.analyze(makeSegments(), [
+      { timestamp: 2.05, reason: 'AI-timestamped issue context', confidence: 0.92 },
+    ]);
+
+    const overlapping = moments.find((moment) => Math.abs(moment.timestamp - 2.05) < 0.2);
+    expect(overlapping).toBeDefined();
+    expect(overlapping?.reason).toMatch(/AI/i);
+  });
+
+  it('prioritizes AI hints when capping a large set', () => {
+    const analyzer = new TranscriptAnalyzer();
+    const segments: TranscriptSegment[] = Array.from({ length: 30 }, (_, index) => {
+      const start = index * 3;
+      return {
+        text: `segment ${index + 1}`,
+        startTime: start,
+        endTime: start + 1.8,
+        confidence: 0.8,
+      };
+    });
+
+    const aiHints: KeyMoment[] = [
+      { timestamp: 12, reason: 'AI-highlighted context', confidence: 0.9 },
+      { timestamp: 33, reason: 'AI-highlighted context', confidence: 0.9 },
+      { timestamp: 54, reason: 'AI-highlighted context', confidence: 0.9 },
+    ];
+
+    const result = analyzer.analyze(segments, aiHints);
+    const aiCount = result.filter((moment) => /AI/i.test(moment.reason)).length;
+
+    expect(result.length).toBeLessThanOrEqual(20);
+    expect(aiCount).toBeGreaterThanOrEqual(2);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"],
+      "@main/*": ["src/main/*"],
+      "@renderer/*": ["src/renderer/*"],
+      "@shared/*": ["src/shared/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "release"]
+}

package/vitest.config.ts

@@ -0,0 +1,46 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    setupFiles: ['./tests/setup.ts'],
+    include: ['tests/**/*.test.ts'],
+    exclude: ['node_modules', 'dist'],
+    // Coverage configuration
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'text-summary', 'json', 'html'],
+      reportsDirectory: './coverage',
+      exclude: [
+        'node_modules/**',
+        'dist/**',
+        'tests/**',
+        '**/*.d.ts',
+        '**/types.ts',
+        '**/*.config.ts',
+        '**/index.ts', // Re-exports
+      ],
+      thresholds: {
+        lines: 8,
+        functions: 30,
+        branches: 55,
+        statements: 8,
+      },
+    },
+    // Test timeouts
+    testTimeout: 10000,
+    hookTimeout: 10000,
+    // Watch mode settings
+    watchExclude: ['node_modules/**', 'dist/**'],
+    // Reporter
+    reporters: ['default'],
+    // Pool settings for better isolation
+    pool: 'forks',
+    poolOptions: {
+      forks: {
+        singleFork: true,
+      },
+    },
+  },
+});