@massu/core 0.1.1 → 0.1.2

package/src/__tests__/backfill-sessions.test.ts

@@ -1,690 +0,0 @@
-// Copyright (c) 2026 Massu. All rights reserved.
-// Licensed under BSL 1.1 - see LICENSE file for details.
-
-// ============================================================
-// backfill-sessions.ts tests
-// The module is a standalone script (no exports), so we test
-// its internal logic by mocking its dependencies and verifying
-// observable side-effects through those mocks.
-// ============================================================
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// ------------------------------------
-// Mock all external dependencies
-// ------------------------------------
-
-vi.mock('fs', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('fs')>();
-  return {
-    ...actual,
-    readdirSync: vi.fn(),
-    statSync: vi.fn(),
-    existsSync: vi.fn(),
-  };
-});
-
-vi.mock('../memory-db.ts', () => ({
-  getMemoryDb: vi.fn(),
-  createSession: vi.fn(),
-  addObservation: vi.fn(),
-  addSummary: vi.fn(),
-  addUserPrompt: vi.fn(),
-  deduplicateFailedAttempt: vi.fn(),
-}));
-
-vi.mock('../transcript-parser.ts', () => ({
-  parseTranscript: vi.fn(),
-  extractUserMessages: vi.fn(),
-  getLastAssistantMessage: vi.fn(),
-}));
-
-vi.mock('../observation-extractor.ts', () => ({
-  extractObservationsFromEntries: vi.fn(),
-}));
-
-vi.mock('../config.ts', () => ({
-  getProjectRoot: vi.fn(() => '/home/user/my-project'),
-  getConfig: vi.fn(() => ({
-    toolPrefix: 'massu',
-    project: { name: 'my-project', root: '/home/user/my-project' },
-  })),
-}));
-
-// Import mocks after vi.mock declarations
-import { readdirSync, statSync, existsSync } from 'fs';
-import {
-  getMemoryDb,
-  createSession,
-  addObservation,
-  addSummary,
-  addUserPrompt,
-  deduplicateFailedAttempt,
-} from '../memory-db.ts';
-import { parseTranscript, extractUserMessages } from '../transcript-parser.ts';
-import { extractObservationsFromEntries } from '../observation-extractor.ts';
-import { getProjectRoot } from '../config.ts';
-
-// ------------------------------------
-// Typed mock references
-// ------------------------------------
-
-const mockReaddirSync = vi.mocked(readdirSync);
-const mockStatSync = vi.mocked(statSync);
-const mockExistsSync = vi.mocked(existsSync);
-const mockGetMemoryDb = vi.mocked(getMemoryDb);
-const mockCreateSession = vi.mocked(createSession);
-const mockAddObservation = vi.mocked(addObservation);
-const mockAddSummary = vi.mocked(addSummary);
-const mockAddUserPrompt = vi.mocked(addUserPrompt);
-const mockDeduplicateFailedAttempt = vi.mocked(deduplicateFailedAttempt);
-const mockParseTranscript = vi.mocked(parseTranscript);
-const mockExtractUserMessages = vi.mocked(extractUserMessages);
-const mockExtractObservationsFromEntries = vi.mocked(extractObservationsFromEntries);
-
-// ------------------------------------
-// Shared mock DB object
-// ------------------------------------
-
-function makeMockDb() {
-  const mockPrepare = vi.fn().mockReturnValue({
-    run: vi.fn(),
-    get: vi.fn(),
-    all: vi.fn(),
-  });
-  return {
-    prepare: mockPrepare,
-    close: vi.fn(),
-  };
-}
-
-// ------------------------------------
-// findTranscriptDir logic tests
-// (tested indirectly via import side-effect + process.env)
-// ------------------------------------
-
-describe('findTranscriptDir logic', () => {
-  const originalHome = process.env.HOME;
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    process.env = { ...originalEnv, HOME: '/home/testuser' };
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-
-  it('uses HOME env variable and project root to build candidate path', () => {
-    // The function resolves: HOME/.claude/projects/<escaped-project-root>
-    // projectRoot = /home/user/my-project
-    // escaped = -home-user-my-project
-    const escapedPath = '/home/user/my-project'.replace(/\//g, '-');
-    const expectedPath = `/home/testuser/.claude/projects/${escapedPath}`;
-
-    // Candidate exists on first try
-    mockExistsSync.mockImplementation((p) => p === expectedPath);
-    mockGetMemoryDb.mockReturnValue(makeMockDb() as ReturnType<typeof getMemoryDb>);
-    mockReaddirSync.mockReturnValue([]);
-
-    // Verify the escaped path calculation logic is correct
-    expect(escapedPath).toBe('-home-user-my-project');
-    expect(expectedPath).toContain('.claude/projects');
-    expect(mockExistsSync).toBeDefined();
-  });
-
-  it('falls back to scanning .claude/projects/ when candidate does not exist', () => {
-    const escapedPath = '/home/user/my-project'.replace(/\//g, '-');
-    const candidatePath = `/home/testuser/.claude/projects/${escapedPath}`;
-    const projectsDir = '/home/testuser/.claude/projects';
-
-    // Candidate does not exist, projects dir does
-    mockExistsSync.mockImplementation((p) => {
-      if (p === candidatePath) return false;
-      if (p === projectsDir) return true;
-      return false;
-    });
-
-    // Fallback finds a match by project name
-    mockReaddirSync.mockImplementation((p) => {
-      if (p === projectsDir) return ['-home-user-my-project', '-other-project'] as unknown as ReturnType<typeof readdirSync>;
-      return [] as unknown as ReturnType<typeof readdirSync>;
-    });
-
-    // Verify the project name matching logic
-    const projectName = 'my-project'; // basename of /home/user/my-project
-    const entries = ['-home-user-my-project', '-other-project'];
-    const match = entries.find(e => e.includes(projectName));
-    expect(match).toBe('-home-user-my-project');
-  });
-
-  it('returns candidate path even when it does not exist (final fallback)', () => {
-    const escapedPath = '/home/user/my-project'.replace(/\//g, '-');
-    const candidatePath = `/home/testuser/.claude/projects/${escapedPath}`;
-    const projectsDir = '/home/testuser/.claude/projects';
-
-    // Neither candidate nor projectsDir exists
-    mockExistsSync.mockReturnValue(false);
-
-    // The function returns candidate in both cases
-    expect(mockExistsSync(candidatePath)).toBe(false);
-    expect(mockExistsSync(projectsDir)).toBe(false);
-  });
-});
-
-// ------------------------------------
-// Transcript processing flow tests
-// ------------------------------------
-
-describe('transcript processing flow', () => {
-  let mockDb: ReturnType<typeof makeMockDb>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockDb = makeMockDb();
-    mockGetMemoryDb.mockReturnValue(mockDb as ReturnType<typeof getMemoryDb>);
-  });
-
-  it('creates a session and processes observations from a single transcript', async () => {
-    const sessionId = 'abc12345-session-1';
-    const filePath = `/tmp/.claude/projects/${sessionId}.jsonl`;
-
-    const mockEntries = [
-      {
-        type: 'user' as const,
-        sessionId,
-        gitBranch: 'main',
-        timestamp: '2026-01-01T10:00:00Z',
-        message: {
-          role: 'user' as const,
-          content: [{ type: 'text' as const, text: 'Fix the login bug' }],
-        },
-      },
-      {
-        type: 'assistant' as const,
-        sessionId,
-        timestamp: '2026-01-01T10:01:00Z',
-        message: {
-          role: 'assistant' as const,
-          content: [{ type: 'text' as const, text: 'Fixed the login bug by updating auth flow' }],
-        },
-      },
-    ];
-
-    const mockObservations = [
-      {
-        type: 'bugfix',
-        title: 'Fixed login auth flow',
-        detail: 'Updated session handling',
-        visibility: 'public' as const,
-        opts: { importance: 3 },
-      },
-      {
-        type: 'decision',
-        title: 'Use JWT tokens for session management',
-        detail: 'Better security than cookies',
-        visibility: 'public' as const,
-        opts: { importance: 5 },
-      },
-    ];
-
-    const mockUserMessages = [
-      { text: 'Fix the login bug', timestamp: '2026-01-01T10:00:00Z' },
-    ];
-
-    mockParseTranscript.mockResolvedValue(mockEntries);
-    mockExtractUserMessages.mockReturnValue(mockUserMessages);
-    mockExtractObservationsFromEntries.mockReturnValue(mockObservations);
-    mockAddObservation.mockReturnValue(1);
-    mockAddUserPrompt.mockReturnValue(1);
-
-    // Simulate the processing logic
-    const entries = await mockParseTranscript(filePath);
-    expect(entries).toHaveLength(2);
-
-    const firstEntry = entries.find(e => e.sessionId);
-    expect(firstEntry?.gitBranch).toBe('main');
-    expect(firstEntry?.timestamp).toBe('2026-01-01T10:00:00Z');
-
-    // Session creation
-    mockCreateSession(mockDb as ReturnType<typeof getMemoryDb>, sessionId, { branch: 'main' });
-    expect(mockCreateSession).toHaveBeenCalledWith(
-      expect.anything(),
-      sessionId,
-      { branch: 'main' }
-    );
-
-    // User prompts
-    const userMessages = mockExtractUserMessages(entries);
-    expect(userMessages).toHaveLength(1);
-    mockAddUserPrompt(mockDb as ReturnType<typeof getMemoryDb>, sessionId, userMessages[0].text, 1);
-    expect(mockAddUserPrompt).toHaveBeenCalledWith(expect.anything(), sessionId, 'Fix the login bug', 1);
-
-    // Observations
-    const observations = mockExtractObservationsFromEntries(entries);
-    expect(observations).toHaveLength(2);
-
-    for (const obs of observations) {
-      if (obs.type === 'failed_attempt') {
-        mockDeduplicateFailedAttempt(
-          mockDb as ReturnType<typeof getMemoryDb>,
-          sessionId,
-          obs.title,
-          obs.detail,
-          obs.opts
-        );
-      } else {
-        mockAddObservation(
-          mockDb as ReturnType<typeof getMemoryDb>,
-          sessionId,
-          obs.type,
-          obs.title,
-          obs.detail,
-          obs.opts
-        );
-      }
-    }
-
-    expect(mockAddObservation).toHaveBeenCalledTimes(2);
-  });
-
-  it('skips empty transcripts', async () => {
-    const filePath = '/tmp/.claude/projects/empty-session.jsonl';
-    mockParseTranscript.mockResolvedValue([]);
-
-    const entries = await mockParseTranscript(filePath);
-    expect(entries).toHaveLength(0);
-
-    // No further processing should occur
-    expect(mockCreateSession).not.toHaveBeenCalled();
-    expect(mockAddObservation).not.toHaveBeenCalled();
-  });
-
-  it('uses deduplicateFailedAttempt for failed_attempt observations', async () => {
-    const filePath = '/tmp/.claude/projects/session-with-failures.jsonl';
-    const sessionId = 'session-with-failures';
-
-    const mockEntries = [
-      {
-        type: 'assistant' as const,
-        sessionId,
-        timestamp: '2026-01-02T10:00:00Z',
-        message: {
-          role: 'assistant' as const,
-          content: [{ type: 'text' as const, text: 'This approach failed due to regex issue' }],
-        },
-      },
-    ];
-
-    const mockObservations = [
-      {
-        type: 'failed_attempt',
-        title: 'Regex parser fails on nested braces',
-        detail: 'Stopped at first closing brace',
-        visibility: 'public' as const,
-        opts: { importance: 5 },
-      },
-    ];
-
-    mockParseTranscript.mockResolvedValue(mockEntries);
-    mockExtractUserMessages.mockReturnValue([]);
-    mockExtractObservationsFromEntries.mockReturnValue(mockObservations);
-
-    const entries = await mockParseTranscript(filePath);
-    const observations = mockExtractObservationsFromEntries(entries);
-
-    for (const obs of observations) {
-      if (obs.type === 'failed_attempt') {
-        mockDeduplicateFailedAttempt(
-          mockDb as ReturnType<typeof getMemoryDb>,
-          sessionId,
-          obs.title,
-          obs.detail,
-          obs.opts
-        );
-      } else {
-        mockAddObservation(
-          mockDb as ReturnType<typeof getMemoryDb>,
-          sessionId,
-          obs.type,
-          obs.title,
-          obs.detail,
-          obs.opts
-        );
-      }
-    }
-
-    expect(mockDeduplicateFailedAttempt).toHaveBeenCalledWith(
-      expect.anything(),
-      sessionId,
-      'Regex parser fails on nested braces',
-      'Stopped at first closing brace',
-      { importance: 5 }
-    );
-    expect(mockAddObservation).not.toHaveBeenCalled();
-  });
-
-  it('generates a summary when observations exist', async () => {
-    const observations = [
-      { type: 'feature', title: 'Add login page', detail: null, visibility: 'public' as const, opts: {} },
-      { type: 'decision', title: 'Use JWT tokens', detail: null, visibility: 'public' as const, opts: {} },
-      { type: 'failed_attempt', title: 'Cookie approach failed', detail: null, visibility: 'public' as const, opts: {} },
-    ];
-
-    const userMessages = [{ text: 'Implement authentication', timestamp: '2026-01-01T10:00:00Z' }];
-
-    // Simulate summary generation logic
-    const completed = observations
-      .filter(o => ['feature', 'bugfix', 'refactor'].includes(o.type))
-      .map(o => `- ${o.title}`)
-      .join('\n');
-
-    const decisions = observations
-      .filter(o => o.type === 'decision')
-      .map(o => `- ${o.title}`)
-      .join('\n');
-
-    const failedAttempts = observations
-      .filter(o => o.type === 'failed_attempt')
-      .map(o => `- ${o.title}`)
-      .join('\n');
-
-    expect(completed).toBe('- Add login page');
-    expect(decisions).toBe('- Use JWT tokens');
-    expect(failedAttempts).toBe('- Cookie approach failed');
-
-    mockAddSummary(mockDb as ReturnType<typeof getMemoryDb>, 'test-session', {
-      request: userMessages[0].text.slice(0, 500),
-      completed: completed || undefined,
-      decisions: decisions || undefined,
-      failedAttempts: failedAttempts || undefined,
-    });
-
-    expect(mockAddSummary).toHaveBeenCalledWith(
-      expect.anything(),
-      'test-session',
-      {
-        request: 'Implement authentication',
-        completed: '- Add login page',
-        decisions: '- Use JWT tokens',
-        failedAttempts: '- Cookie approach failed',
-      }
-    );
-  });
-
-  it('truncates long user prompts to 5000 characters', () => {
-    const longText = 'x'.repeat(6000);
-    const truncated = longText.slice(0, 5000);
-    expect(truncated).toHaveLength(5000);
-    expect(longText.slice(0, 5000)).toHaveLength(5000);
-  });
-
-  it('processes at most 50 user messages per session', () => {
-    const manyMessages = Array.from({ length: 75 }, (_, i) => ({
-      text: `Prompt ${i + 1}`,
-      timestamp: `2026-01-01T10:${String(i).padStart(2, '0')}:00Z`,
-    }));
-
-    const limit = Math.min(manyMessages.length, 50);
-    expect(limit).toBe(50);
-    expect(manyMessages.slice(0, limit)).toHaveLength(50);
-  });
-});
-
-// ------------------------------------
-// sessionId extraction tests
-// ------------------------------------
-
-describe('sessionId extraction from file path', () => {
-  it('extracts session id from full file path', () => {
-    const filePath = '/home/user/.claude/projects/-home-user-my-project/abc123def456.jsonl';
-    const sessionId = filePath.split('/').pop()?.replace('.jsonl', '') ?? 'unknown';
-    expect(sessionId).toBe('abc123def456');
-  });
-
-  it('returns empty string for empty path (pop returns empty string, not undefined)', () => {
-    // ''.split('/').pop() returns '' (not undefined), so ?? 'unknown' does not fire
-    const filePath = '';
-    const sessionId = filePath.split('/').pop()?.replace('.jsonl', '') ?? 'unknown';
-    // empty string is falsy but not null/undefined, so nullish coalescing returns ''
-    expect(sessionId).toBe('');
-  });
-
-  it('handles session IDs with dashes and underscores', () => {
-    const filePath = '/tmp/sessions/my-session_2026-01-01.jsonl';
-    const sessionId = filePath.split('/').pop()?.replace('.jsonl', '') ?? 'unknown';
-    expect(sessionId).toBe('my-session_2026-01-01');
-  });
-});
-
-// ------------------------------------
-// Error handling tests
-// ------------------------------------
-
-describe('error handling', () => {
-  let mockDb: ReturnType<typeof makeMockDb>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockDb = makeMockDb();
-    mockGetMemoryDb.mockReturnValue(mockDb as ReturnType<typeof getMemoryDb>);
-  });
-
-  it('handles parseTranscript failure gracefully (continues to next file)', async () => {
-    const file1 = '/tmp/sessions/session1.jsonl';
-    const file2 = '/tmp/sessions/session2.jsonl';
-
-    mockParseTranscript
-      .mockRejectedValueOnce(new Error('JSONL parse error'))
-      .mockResolvedValueOnce([
-        {
-          type: 'user' as const,
-          sessionId: 'session2',
-          gitBranch: 'main',
-          timestamp: '2026-01-02T10:00:00Z',
-          message: {
-            role: 'user' as const,
-            content: [{ type: 'text' as const, text: 'Fix it' }],
-          },
-        },
-      ]);
-
-    mockExtractUserMessages.mockReturnValue([{ text: 'Fix it' }]);
-    mockExtractObservationsFromEntries.mockReturnValue([]);
-
-    // Process file 1: should fail
-    let session1Error: Error | null = null;
-    try {
-      await mockParseTranscript(file1);
-    } catch (e) {
-      session1Error = e as Error;
-    }
-    expect(session1Error?.message).toBe('JSONL parse error');
-
-    // Process file 2: should succeed
-    const entries2 = await mockParseTranscript(file2);
-    expect(entries2).toHaveLength(1);
-  });
-
-  it('handles addObservation errors per-observation (continues to next)', () => {
-    const sessionId = 'test-session';
-    mockAddObservation
-      .mockImplementationOnce(() => { throw new Error('DB constraint'); })
-      .mockReturnValueOnce(2);
-
-    const observations = [
-      { type: 'bugfix', title: 'Fix 1', detail: null, opts: {} },
-      { type: 'feature', title: 'Feature 1', detail: null, opts: {} },
-    ];
-
-    let successCount = 0;
-    for (const obs of observations) {
-      try {
-        mockAddObservation(
-          mockDb as ReturnType<typeof getMemoryDb>,
-          sessionId,
-          obs.type,
-          obs.title,
-          obs.detail,
-          obs.opts
-        );
-        successCount++;
-      } catch (_e) {
-        // Skip on error - same behavior as backfill-sessions.ts
-      }
-    }
-
-    expect(successCount).toBe(1);
-    expect(mockAddObservation).toHaveBeenCalledTimes(2);
-  });
-
-  it('ensures db.close() is always called (finally block)', () => {
-    // Even if processing throws, close should be called
-    mockGetMemoryDb.mockReturnValue(mockDb as ReturnType<typeof getMemoryDb>);
-
-    const db = mockGetMemoryDb();
-    try {
-      throw new Error('Unexpected error during processing');
-    } catch (_e) {
-      // Handled
-    } finally {
-      db.close();
-    }
-
-    expect(mockDb.close).toHaveBeenCalledTimes(1);
-  });
-
-  it('handles readdirSync failure for transcript directory', () => {
-    mockExistsSync.mockReturnValue(true);
-    mockReaddirSync.mockImplementation(() => {
-      throw new Error('ENOENT: no such file or directory');
-    });
-
-    let caughtError: Error | null = null;
-    let files: string[] = [];
-    try {
-      files = (readdirSync('/nonexistent') as unknown as string[])
-        .filter((f: string) => f.endsWith('.jsonl'));
-    } catch (e) {
-      caughtError = e as Error;
-    }
-
-    expect(caughtError).not.toBeNull();
-    expect(caughtError?.message).toContain('ENOENT');
-    expect(files).toHaveLength(0);
-  });
-
-  it('handles addSummary errors without propagating', () => {
-    mockAddSummary.mockImplementationOnce(() => { throw new Error('Summary duplicate'); });
-
-    let threw = false;
-    try {
-      mockAddSummary(mockDb as ReturnType<typeof getMemoryDb>, 'test-session', {
-        request: 'Fix the bug',
-      });
-    } catch (_e) {
-      threw = true;
-    }
-
-    // The backfill script silently skips summary errors
-    expect(threw).toBe(true);
-    expect(mockAddSummary).toHaveBeenCalledOnce();
-  });
-});
-
-// ------------------------------------
-// MAX_SESSIONS cap tests
-// ------------------------------------
-
-describe('MAX_SESSIONS cap', () => {
-  it('caps session processing at 20 files', () => {
-    const MAX_SESSIONS = 20;
-    const allFiles = Array.from({ length: 35 }, (_, i) => ({
-      name: `session-${i}.jsonl`,
-      mtime: Date.now() - i * 1000,
-    }));
-
-    const processed = allFiles
-      .sort((a, b) => b.mtime - a.mtime)
-      .slice(0, MAX_SESSIONS);
-
-    expect(processed).toHaveLength(20);
-    // Most recent should be first
-    expect(processed[0].name).toBe('session-0.jsonl');
-  });
-
-  it('sorts files by modification time (most recent first)', () => {
-    const files = [
-      { name: 'old.jsonl', mtime: 1000 },
-      { name: 'newest.jsonl', mtime: 3000 },
-      { name: 'middle.jsonl', mtime: 2000 },
-    ];
-
-    const sorted = files.sort((a, b) => b.mtime - a.mtime);
-    expect(sorted[0].name).toBe('newest.jsonl');
-    expect(sorted[1].name).toBe('middle.jsonl');
-    expect(sorted[2].name).toBe('old.jsonl');
-  });
-
-  it('only processes .jsonl files', () => {
-    const allFiles = ['session1.jsonl', 'README.md', 'session2.jsonl', 'config.json', 'session3.jsonl'];
-    const jsonlFiles = allFiles.filter(f => f.endsWith('.jsonl'));
-    expect(jsonlFiles).toHaveLength(3);
-    expect(jsonlFiles).toEqual(['session1.jsonl', 'session2.jsonl', 'session3.jsonl']);
-  });
-});
-
-// ------------------------------------
-// Summary generation logic tests
-// ------------------------------------
-
-describe('summary generation logic', () => {
-  it('only generates summary when observations exist', () => {
-    const observations: { type: string; title: string }[] = [];
-    const shouldGenerate = observations.length > 0;
-    expect(shouldGenerate).toBe(false);
-  });
-
-  it('generates summary for non-empty observation lists', () => {
-    const observations = [
-      { type: 'feature', title: 'New auth module' },
-    ];
-    const shouldGenerate = observations.length > 0;
-    expect(shouldGenerate).toBe(true);
-  });
-
-  it('includes completed items from feature/bugfix/refactor types', () => {
-    const observations = [
-      { type: 'feature', title: 'Add login' },
-      { type: 'bugfix', title: 'Fix token expiry' },
-      { type: 'refactor', title: 'Clean up auth helpers' },
-      { type: 'decision', title: 'Use JWT' },
-      { type: 'failed_attempt', title: 'Cookie approach failed' },
-    ];
-
-    const completed = observations
-      .filter(o => ['feature', 'bugfix', 'refactor'].includes(o.type))
-      .map(o => `- ${o.title}`)
-      .join('\n');
-
-    expect(completed).toBe('- Add login\n- Fix token expiry\n- Clean up auth helpers');
-  });
-
-  it('uses undefined for empty completed/decisions/failedAttempts in summary', () => {
-    const observations = [{ type: 'discovery', title: 'Found legacy code' }];
-
-    const completed = observations
-      .filter(o => ['feature', 'bugfix', 'refactor'].includes(o.type))
-      .map(o => `- ${o.title}`)
-      .join('\n');
-
-    const decisions = observations
-      .filter(o => o.type === 'decision')
-      .map(o => `- ${o.title}`)
-      .join('\n');
-
-    expect(completed || undefined).toBeUndefined();
-    expect(decisions || undefined).toBeUndefined();
-  });
-});