バイト予算付き2フェーズリポジトリウォーク

import { promises as fs } from 'node:fs'
import { join, extname } from 'node:path'

interface FileEntry {
  path: string
  size: number
}

interface ParsedFile {
  path: string
  content: string
  ast?: unknown // AST や解析結果
}

interface WalkOptions {
  /** 解析対象の拡張子（例: ['.ts', '.js']） */
  parseableExtensions: string[]
  /** ignore するパターン（例: node_modules, .git） */
  ignorePatterns: RegExp[]
  /** 1チャンクの最大バイト数 */
  chunkBudget: number
  /** 単一ファイルの最大サイズ（これを超えるファイルはスキップ） */
  maxFileSize: number
}

/**
 * フェーズ1: pathとsizeだけをスキャン
 */
async function scanPaths(
  rootPath: string,
  options: WalkOptions
): Promise<FileEntry[]> {
  const entries: FileEntry[] = []

  async function walk(dir: string): Promise<void> {
    const items = await fs.readdir(dir, { withFileTypes: true })

    for (const item of items) {
      const fullPath = join(dir, item.name)

      // ignoreパターンチェック（メモリ効率のため先に判定）
      if (options.ignorePatterns.some((pattern) => pattern.test(fullPath))) {
        continue
      }

      if (item.isDirectory()) {
        await walk(fullPath)
      } else if (item.isFile()) {
        const stat = await fs.stat(fullPath)

        // サイズチェック（巨大ファイルを早期除外）
        if (stat.size > options.maxFileSize) {
          continue
        }

        entries.push({
          path: fullPath,
          size: stat.size
        })
      }
    }
  }

  await walk(rootPath)
  return entries
}

/**
 * フェーズ2: 構造解析とフィルタリング
 */
function analyzeStructure(
  entries: FileEntry[],
  options: WalkOptions
): FileEntry[] {
  // 拡張子でフィルタ
  const parseableFiles = entries.filter((entry) => {
    const ext = extname(entry.path)
    return options.parseableExtensions.includes(ext)
  })

  // サイズ順にソート（小さいファイルから処理すると早期結果が得られやすい）
  return parseableFiles.toSorted((a, b) => a.size - b.size)
}

/**
 * フェーズ3: byte budgetでchunkingして順次read/parse
 */
async function parseWithBudget(
  entries: FileEntry[],
  options: WalkOptions,
  parseFile: (content: string, path: string) => unknown
): Promise<ParsedFile[]> {
  const results: ParsedFile[] = []
  let currentBudget = 0
  let chunk: FileEntry[] = []

  for (const entry of entries) {
    // budgetを超えたらチャンク処理
    if (currentBudget + entry.size > options.chunkBudget) {
      // 現在のチャンクを処理
      const parsed = await processChunk(chunk, parseFile)
      results.push(...parsed)

      // リセット（GCがメモリを回収できる）
      chunk = []
      currentBudget = 0
    }

    chunk.push(entry)
    currentBudget += entry.size
  }

  // 最後のチャンクを処理
  if (chunk.length > 0) {
    const parsed = await processChunk(chunk, parseFile)
    results.push(...parsed)
  }

  return results
}

/**
 * チャンク内のファイルを一括読み取り・解析
 */
async function processChunk(
  chunk: FileEntry[],
  parseFile: (content: string, path: string) => unknown
): Promise<ParsedFile[]> {
  const results: ParsedFile[] = []

  // 並列読み取り（チャンク内は同時実行でI/O効率化）
  const readPromises = chunk.map(async (entry) => {
    try {
      const content = await fs.readFile(entry.path, 'utf-8')
      const ast = parseFile(content, entry.path)
      return { path: entry.path, content, ast }
    } catch (error) {
      console.warn(`Failed to parse ${entry.path}:`, error)
      return null
    }
  })

  const parsed = await Promise.all(readPromises)

  for (const result of parsed) {
    if (result) {
      results.push(result)
    }
  }

  return results
}

/**
 * 統合インターフェース
 */
export async function walkRepository(
  rootPath: string,
  options: WalkOptions,
  parseFile: (content: string, path: string) => unknown
): Promise<ParsedFile[]> {
  // フェーズ1: pathとsizeをスキャン
  const entries = await scanPaths(rootPath, options)

  // フェーズ2: 構造解析
  const parseableFiles = analyzeStructure(entries, options)

  // フェーズ3: byte budgetで順次parse
  const results = await parseWithBudget(parseableFiles, options, parseFile)

  return results
}

import { parse } from '@typescript-eslint/typescript-estree'

// TypeScriptリポジトリを解析
const results = await walkRepository(
  './my-project',
  {
    parseableExtensions: ['.ts', '.tsx', '.js', '.jsx'],
    ignorePatterns: [
      /node_modules/,
      /\.git/,
      /dist/,
      /build/
    ],
    chunkBudget: 50 * 1024 * 1024, // 50MB
    maxFileSize: 10 * 1024 * 1024    // 10MB
  },
  (content, path) => {
    // ASTパーサーを適用
    return parse(content, {
      filePath: path,
      jsx: true
    })
  }
)

console.log(`Parsed ${results.length} files`)