claude-code/src/utils/__tests__/claudemd.test.ts

import { describe, expect, test } from 'bun:test'
import {
  stripHtmlComments,
  isMemoryFilePath,
  getLargeMemoryFiles,
  MAX_MEMORY_CHARACTER_COUNT,
  type MemoryFileInfo,
} from '../claudemd'

function mockMemoryFile(
  overrides: Partial<MemoryFileInfo> = {},
): MemoryFileInfo {
  return {
    path: '/project/CLAUDE.md',
    type: 'Project',
    content: 'test content',
    ...overrides,
  }
}

describe('stripHtmlComments', () => {
  test('strips block-level HTML comments (own line)', () => {
    // CommonMark type-2 HTML blocks: comment must start at beginning of line
    const result = stripHtmlComments('text\n<!-- block comment -->\nmore')
    expect(result.content).not.toContain('block comment')
    expect(result.stripped).toBe(true)
  })

  test('returns stripped: false when no comments', () => {
    const result = stripHtmlComments('no comments here')
    expect(result.stripped).toBe(false)
    expect(result.content).toBe('no comments here')
  })

  test('returns stripped: true when block comments exist', () => {
    const result = stripHtmlComments('hello\n<!-- world -->\nend')
    expect(result.stripped).toBe(true)
  })

  test('handles empty string', () => {
    const result = stripHtmlComments('')
    expect(result.content).toBe('')
    expect(result.stripped).toBe(false)
  })

  test('handles multiple block comments', () => {
    const result = stripHtmlComments('a\n<!-- c1 -->\nb\n<!-- c2 -->\nc')
    expect(result.content).not.toContain('c1')
    expect(result.content).not.toContain('c2')
    expect(result.stripped).toBe(true)
  })

  test('preserves code block content', () => {
    const input = 'text\n```html\n<!-- not stripped -->\n```\nmore'
    const result = stripHtmlComments(input)
    expect(result.content).toContain('<!-- not stripped -->')
  })

  test('preserves inline comments within paragraphs', () => {
    // Inline comments are NOT stripped (CommonMark paragraph semantics)
    const result = stripHtmlComments('text <!-- inline --> more')
    expect(result.content).toContain('<!-- inline -->')
    expect(result.stripped).toBe(false)
  })

  test('leaves unclosed HTML comment unchanged', () => {
    const result = stripHtmlComments('<!-- no close some text')
    expect(result.content).toBe('<!-- no close some text')
    expect(result.stripped).toBe(false)
  })

  test('strips comment and keeps same-line residual content', () => {
    const result = stripHtmlComments('<!-- note -->some text')
    expect(result.content).toContain('some text')
    expect(result.content).not.toContain('<!--')
    expect(result.stripped).toBe(true)
  })
})

describe('isMemoryFilePath', () => {
  test('returns true for CLAUDE.md path', () => {
    expect(isMemoryFilePath('/project/CLAUDE.md')).toBe(true)
  })

  test('returns true for CLAUDE.local.md path', () => {
    expect(isMemoryFilePath('/project/CLAUDE.local.md')).toBe(true)
  })

  test('returns true for .claude/rules/ path', () => {
    expect(isMemoryFilePath('/project/.claude/rules/foo.md')).toBe(true)
  })

  test('returns false for regular file', () => {
    expect(isMemoryFilePath('/project/src/main.ts')).toBe(false)
  })

  test('returns false for unrelated .md file', () => {
    expect(isMemoryFilePath('/project/README.md')).toBe(false)
  })

  test('returns false for .claude directory non-rules file', () => {
    expect(isMemoryFilePath('/project/.claude/settings.json')).toBe(false)
  })

  test('returns false for lowercase claude.md (case-sensitive match)', () => {
    expect(isMemoryFilePath('/project/claude.md')).toBe(false)
  })

  test('returns false for non-.md file in .claude/rules/', () => {
    expect(isMemoryFilePath('.claude/rules/foo.txt')).toBe(false)
  })
})

describe('getLargeMemoryFiles', () => {
  test('returns files exceeding threshold', () => {
    const largeContent = 'x'.repeat(MAX_MEMORY_CHARACTER_COUNT + 1)
    const files = [
      mockMemoryFile({ content: 'small' }),
      mockMemoryFile({ content: largeContent, path: '/big.md' }),
    ]
    const result = getLargeMemoryFiles(files)
    expect(result).toHaveLength(1)
    expect(result[0].path).toBe('/big.md')
  })

  test('returns empty array when all files are small', () => {
    const files = [
      mockMemoryFile({ content: 'small' }),
      mockMemoryFile({ content: 'also small' }),
    ]
    expect(getLargeMemoryFiles(files)).toEqual([])
  })

  test('correctly identifies threshold boundary', () => {
    const atThreshold = 'x'.repeat(MAX_MEMORY_CHARACTER_COUNT)
    const overThreshold = 'x'.repeat(MAX_MEMORY_CHARACTER_COUNT + 1)
    const files = [
      mockMemoryFile({ content: atThreshold }),
      mockMemoryFile({ content: overThreshold }),
    ]
    const result = getLargeMemoryFiles(files)
    expect(result).toHaveLength(1)
  })

  test('returns empty array for empty input', () => {
    expect(getLargeMemoryFiles([])).toEqual([])
  })
})