4장: 컨텍스트 선택과 검색 전략

@src/auth/middleware.ts 이 미들웨어에 rate limiting을 추가해주세요.
@src/auth/ 디렉토리의 패턴을 참고해서 작성해주세요.
@types/auth.d.ts 이 타입 정의를 사용해야 합니다.

// @context: 인증 미들웨어의 핵심 로직
// @related: src/auth/jwt.ts, src/auth/types.ts
// @pattern: Express middleware chain
 
export function verifyToken(req: Request, res: Response, next: NextFunction) {
  const token = extractBearerToken(req.headers.authorization);
  if (!token) {
    return res.status(401).json({ error: "Token required" });
  }
  // ...
}

interface OpenFileContext {
  // 현재 활성 파일 (가장 높은 우선순위)
  activeFile: FileContent;
  
  // 열린 탭의 파일들 (최근 접근 순)
  openTabs: FileContent[];
  
  // 최근 수정한 파일들
  recentlyModified: FileContent[];
}

async function traceImports(filePath: string, depth: number = 2): Promise<string[]> {
  const content = await readFile(filePath);
  const imports = parseImportStatements(content);
  
  const resolved: string[] = [];
  for (const imp of imports) {
    const resolvedPath = resolveImportPath(imp, filePath);
    resolved.push(resolvedPath);
    
    // 재귀적 추적 (depth 제한)
    if (depth > 1) {
      const nested = await traceImports(resolvedPath, depth - 1);
      resolved.push(...nested);
    }
  }
  
  return [...new Set(resolved)]; // 중복 제거
}

async function findCoChangedFiles(
  filePath: string,
  lookback: number = 100
): Promise<FileCorrelation[]> {
  // 최근 N개 커밋에서 함께 변경된 파일 분석
  const commits = await getCommitsContaining(filePath, lookback);
  const coChanges = new Map<string, number>();
  
  for (const commit of commits) {
    const files = await getCommitFiles(commit);
    for (const file of files) {
      if (file !== filePath) {
        coChanges.set(file, (coChanges.get(file) ?? 0) + 1);
      }
    }
  }
  
  // 동시 변경 빈도가 높은 순으로 정렬
  return [...coChanges.entries()]
    .map(([file, count]) => ({ file, correlation: count / commits.length }))
    .sort((a, b) => b.correlation - a.correlation);
}

function chunkByAST(sourceCode: string): CodeChunk[] {
  const ast = parse(sourceCode);
  const chunks: CodeChunk[] = [];
  
  // 최상위 선언 단위로 분할
  for (const node of ast.body) {
    switch (node.type) {
      case "FunctionDeclaration":
      case "ClassDeclaration":
      case "ExportNamedDeclaration":
      case "ExportDefaultDeclaration":
        chunks.push({
          content: sourceCode.slice(node.start, node.end),
          type: node.type,
          name: getNodeName(node),
          startLine: node.loc.start.line,
          endLine: node.loc.end.line,
        });
        break;
    }
  }
  
  return chunks;
}

async function selectByDependencyGraph(
  targetFile: string,
  direction: "downstream" | "upstream" | "both",
  maxDepth: number = 2
): Promise<string[]> {
  const graph = await buildDependencyGraph();
  const selected = new Set<string>();
  
  function traverse(file: string, depth: number) {
    if (depth > maxDepth || selected.has(file)) return;
    selected.add(file);
    
    if (direction === "downstream" || direction === "both") {
      for (const dep of graph.getDependencies(file)) {
        traverse(dep, depth + 1);
      }
    }
    
    if (direction === "upstream" || direction === "both") {
      for (const dep of graph.getDependents(file)) {
        traverse(dep, depth + 1);
      }
    }
  }
  
  traverse(targetFile, 0);
  return [...selected];
}

interface ImpactAnalysis {
  // 직접 영향: 변경된 파일을 직접 참조하는 파일
  directImpact: string[];
  
  // 간접 영향: 직접 영향 파일을 참조하는 파일
  indirectImpact: string[];
  
  // 테스트 영향: 변경으로 인해 실행해야 하는 테스트
  affectedTests: string[];
  
  // 타입 영향: 변경된 타입을 사용하는 파일
  typeImpact: string[];
}
 
async function analyzeImpact(changedFiles: string[]): Promise<ImpactAnalysis> {
  const graph = await buildDependencyGraph();
  
  const directImpact = new Set<string>();
  const indirectImpact = new Set<string>();
  
  // 1단계: 직접 영향
  for (const file of changedFiles) {
    for (const dependent of graph.getDependents(file)) {
      directImpact.add(dependent);
    }
  }
  
  // 2단계: 간접 영향
  for (const file of directImpact) {
    for (const dependent of graph.getDependents(file)) {
      if (!directImpact.has(dependent) && !changedFiles.includes(dependent)) {
        indirectImpact.add(dependent);
      }
    }
  }
  
  // 3단계: 영향받는 테스트 식별
  const affectedTests = await findAffectedTests([
    ...changedFiles,
    ...directImpact,
  ]);
  
  return {
    directImpact: [...directImpact],
    indirectImpact: [...indirectImpact],
    affectedTests,
    typeImpact: await findTypeImpact(changedFiles),
  };
}