5장: 컨텍스트 압축과 정보 밀도 최적화

// 원본: 45줄, ~600 토큰
export class UserService {
  private repository: UserRepository;
  private cache: CacheService;
  private logger: Logger;
 
  constructor(repo: UserRepository, cache: CacheService, logger: Logger) {
    this.repository = repo;
    this.cache = cache;
    this.logger = logger;
  }
 
  async findById(id: string): Promise<User | null> {
    const cached = await this.cache.get(`user:${id}`);
    if (cached) {
      this.logger.debug("Cache hit", { id });
      return JSON.parse(cached);
    }
    
    const user = await this.repository.findOne({ id });
    if (user) {
      await this.cache.set(`user:${id}`, JSON.stringify(user), { ttl: 3600 });
    }
    
    return user;
  }
 
  async create(data: CreateUserDTO): Promise<User> {
    const existing = await this.repository.findOne({ email: data.email });
    if (existing) {
      throw new ConflictError("Email already exists");
    }
    
    const hashed = await hashPassword(data.password);
    const user = await this.repository.create({ ...data, password: hashed });
    this.logger.info("User created", { userId: user.id });
    return user;
  }
 
  async updateRole(id: string, role: Role): Promise<User> {
    const user = await this.findById(id);
    if (!user) throw new NotFoundError("User not found");
    
    const updated = await this.repository.update(id, { role });
    await this.cache.delete(`user:${id}`);
    this.logger.info("Role updated", { userId: id, role });
    return updated;
  }
}

// 압축 후: 12줄, ~150 토큰 (75% 감소)
export class UserService {
  constructor(repo: UserRepository, cache: CacheService, logger: Logger);
  
  findById(id: string): Promise<User | null>;
  create(data: CreateUserDTO): Promise<User>;
  // throws ConflictError if email exists
  updateRole(id: string, role: Role): Promise<User>;
  // throws NotFoundError if user not found, invalidates cache
}

import ts from "typescript";
 
function extractInterface(sourceCode: string): string {
  const sourceFile = ts.createSourceFile(
    "temp.ts",
    sourceCode,
    ts.ScriptTarget.Latest,
    true
  );
  
  const signatures: string[] = [];
  
  function visit(node: ts.Node) {
    if (ts.isFunctionDeclaration(node) && node.name) {
      const params = node.parameters
        .map(p => `${p.name.getText()}: ${p.type?.getText() ?? "unknown"}`)
        .join(", ");
      const returnType = node.type?.getText() ?? "void";
      signatures.push(`function ${node.name.getText()}(${params}): ${returnType};`);
    }
    
    if (ts.isClassDeclaration(node) && node.name) {
      const methods = node.members
        .filter(ts.isMethodDeclaration)
        .map(m => {
          const params = m.parameters
            .map(p => `${p.name.getText()}: ${p.type?.getText() ?? "unknown"}`)
            .join(", ");
          const returnType = m.type?.getText() ?? "void";
          const modifier = m.modifiers?.some(
            mod => mod.kind === ts.SyntaxKind.AsyncKeyword
          ) ? "async " : "";
          return `  ${modifier}${m.name.getText()}(${params}): ${returnType};`;
        });
      
      signatures.push(
        `class ${node.name.getText()} {\n${methods.join("\n")}\n}`
      );
    }
    
    ts.forEachChild(node, visit);
  }
  
  visit(sourceFile);
  return signatures.join("\n\n");
}

async function summarizeConversation(
  messages: Message[],
  maxTokens: number
): Promise<Message[]> {
  const totalTokens = countTokens(messages);
  
  if (totalTokens <= maxTokens) {
    return messages; // 압축 불필요
  }
  
  // 오래된 메시지를 요약 대상으로 선택
  const recentCount = 5;
  const toSummarize = messages.slice(0, -recentCount);
  const recentMessages = messages.slice(-recentCount);
  
  // LLM에게 요약 요청
  const summary = await llm.complete({
    system: "이전 대화의 핵심 결정사항과 컨텍스트를 간결하게 요약하세요.",
    messages: [
      {
        role: "user",
        content: formatMessagesForSummary(toSummarize),
      },
    ],
  });
  
  return [
    { role: "system", content: `[이전 대화 요약]\n${summary}` },
    ...recentMessages,
  ];
}

src/
  app/
    layout.tsx
    page.tsx
    globals.css
    auth/
      login/
        page.tsx
        loading.tsx
      register/
        page.tsx
      layout.tsx
    dashboard/
      page.tsx
      settings/
        page.tsx
        profile/
          page.tsx
  components/
    ui/
      Button.tsx
      Input.tsx
      Modal.tsx
      Card.tsx
    layout/
      Header.tsx
      Footer.tsx
      Sidebar.tsx
    auth/
      LoginForm.tsx
      RegisterForm.tsx
  lib/
    utils.ts
    auth.ts
    db.ts
    validation.ts

src/
  app/           # App Router pages (auth, dashboard)
  components/    # UI (Button, Input, Modal...), layout, auth forms
  lib/           # utils, auth, db, validation

src/ - app(pages), components(ui+layout), lib(utilities)

interface ChunkStrategy {
  // 관련 함수만 추출
  extractRelevantFunctions(
    file: string,
    query: string
  ): Promise<CodeChunk[]>;
  
  // 주변 컨텍스트와 함께 추출
  extractWithContext(
    file: string,
    targetLine: number,
    contextLines: number
  ): Promise<CodeChunk>;
  
  // 타입 정의만 추출
  extractTypes(file: string): Promise<TypeDefinition[]>;
}
 
// 사용 예시
async function buildCompressedContext(task: string): Promise<string> {
  const relevantFiles = await selectFiles(task);
  const chunks: string[] = [];
  
  for (const file of relevantFiles) {
    if (isLargeFile(file)) {
      // 큰 파일: 관련 부분만 추출
      const relevantChunks = await extractRelevantFunctions(file, task);
      chunks.push(formatChunks(file, relevantChunks));
    } else {
      // 작은 파일: 전체 포함
      chunks.push(await readFile(file));
    }
  }
  
  return chunks.join("\n\n");
}

interface CompressionMetrics {
  // 원본 대비 압축 비율
  compressionRatio: number; // 압축 후 토큰 / 원본 토큰
  
  // 정보 보존율 (작업 성공률로 간접 측정)
  informationRetention: number; // 0.0 ~ 1.0
  
  // 토큰당 정보 밀도
  informationDensity: number; // 유용한 정보량 / 토큰 수
  
  // 비용 절감률
  costReduction: number; // (원본 비용 - 압축 후 비용) / 원본 비용
}
 
function calculateMetrics(
  original: string,
  compressed: string,
  taskSuccessRate: number
): CompressionMetrics {
  const originalTokens = countTokens(original);
  const compressedTokens = countTokens(compressed);
  
  return {
    compressionRatio: compressedTokens / originalTokens,
    informationRetention: taskSuccessRate,
    informationDensity: taskSuccessRate / compressedTokens,
    costReduction: 1 - (compressedTokens / originalTokens),
  };
}

async function validateCompression(
  original: Context,
  compressed: Context,
  testTasks: Task[]
): Promise<ValidationResult> {
  const results = {
    original: { successes: 0, failures: 0 },
    compressed: { successes: 0, failures: 0 },
  };
  
  for (const task of testTasks) {
    // 원본 컨텍스트로 작업 수행
    const originalResult = await executeTask(task, original);
    if (originalResult.success) results.original.successes++;
    else results.original.failures++;
    
    // 압축된 컨텍스트로 동일 작업 수행
    const compressedResult = await executeTask(task, compressed);
    if (compressedResult.success) results.compressed.successes++;
    else results.compressed.failures++;
  }
  
  const successRateDrop =
    (results.original.successes - results.compressed.successes) /
    testTasks.length;
  
  return {
    originalSuccessRate: results.original.successes / testTasks.length,
    compressedSuccessRate: results.compressed.successes / testTasks.length,
    successRateDrop,
    acceptable: successRateDrop < 0.05, // 5% 이내 허용
  };
}