chekk 0.5.4 → 1.0.0

package/src/parsers/codex.js

@@ -1,188 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Parse OpenAI Codex CLI session files into normalized format.
- *
- * Codex stores sessions under:
- *   ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
- *
- * Each JSONL line follows the OpenAI message format:
- *   { "role": "user"|"assistant"|"system", "content": "..." | [...], "timestamp": "..." }
- *
- * Tool calls appear as content blocks with type "function_call" or "tool_use".
- * We normalize into the same session format as Claude Code.
- */
-
-function parseJsonlLine(line) {
-  try {
-    return JSON.parse(line);
-  } catch {
-    return null;
-  }
-}
-
-function extractText(content) {
-  if (typeof content === 'string') return content;
-  if (!Array.isArray(content)) return '';
-  return content
-    .filter(block => block.type === 'text' || block.type === 'output_text')
-    .map(block => block.text || block.content || '')
-    .join('\n');
-}
-
-function extractToolCalls(content) {
-  if (!Array.isArray(content)) return [];
-  return content
-    .filter(block =>
-      block.type === 'function_call' ||
-      block.type === 'tool_use' ||
-      block.type === 'tool_call'
-    )
-    .map(block => ({
-      tool: block.name || block.function?.name || 'unknown',
-      input: block.arguments || block.input || {},
-    }));
-}
-
-/**
- * Parse a single Codex rollout JSONL file.
- */
-function parseSessionFile(filePath) {
-  let raw;
-  try {
-    raw = readFileSync(filePath, 'utf-8');
-  } catch {
-    return [];
-  }
-
-  const lines = raw.split('\n').filter(l => l.trim());
-  const exchanges = [];
-  let current = null;
-
-  for (const line of lines) {
-    const entry = parseJsonlLine(line);
-    if (!entry) continue;
-
-    const role = entry.role;
-    if (!role) continue;
-
-    // Skip system messages
-    if (role === 'system') continue;
-
-    // Skip tool result messages
-    if (role === 'tool' || role === 'function') continue;
-
-    const text = extractText(entry.content);
-    const tools = role === 'assistant' ? extractToolCalls(entry.content) : [];
-    const timestamp = entry.timestamp || entry.created_at || null;
-
-    if (role === 'user') {
-      if (!text.trim()) continue;
-      if (current) exchanges.push(current);
-      current = {
-        userPrompt: text,
-        userTimestamp: timestamp,
-        assistantResponses: [],
-        toolCalls: [],
-        thinkingContent: [],
-      };
-    } else if (role === 'assistant' && current) {
-      if (text) current.assistantResponses.push(text);
-      current.toolCalls.push(...tools);
-
-      // Codex may include reasoning/thinking
-      if (entry.reasoning || entry.thinking) {
-        current.thinkingContent.push(entry.reasoning || entry.thinking);
-      }
-    }
-  }
-
-  if (current) exchanges.push(current);
-  return exchanges;
-}
-
-/**
- * Recursively find all rollout-*.jsonl files under sessions dir.
- */
-function findSessionFiles(dir) {
-  const files = [];
-  if (!existsSync(dir)) return files;
-
-  try {
-    const entries = readdirSync(dir);
-    for (const entry of entries) {
-      const fullPath = join(dir, entry);
-      try {
-        const stat = statSync(fullPath);
-        if (stat.isDirectory()) {
-          files.push(...findSessionFiles(fullPath));
-        } else if (entry.endsWith('.jsonl')) {
-          files.push(fullPath);
-        }
-      } catch {
-        continue;
-      }
-    }
-  } catch {
-    // Ignore permission errors
-  }
-
-  return files;
-}
-
-/**
- * Extract project name from session file path or content.
- * Codex sessions are in ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
- * Try to get the working directory from the session content.
- */
-function extractProjectName(filePath, exchanges) {
-  // Try to extract from the file path date structure
-  const parts = filePath.split('/');
-  const dateIdx = parts.findIndex(p => p === 'sessions');
-  if (dateIdx >= 0 && parts.length > dateIdx + 3) {
-    return `codex/${parts[dateIdx + 1]}/${parts[dateIdx + 2]}/${parts[dateIdx + 3]}`;
-  }
-  return 'codex';
-}
-
-/**
- * Parse all Codex sessions from ~/.codex/sessions.
- */
-export function parseAllSessions(basePath) {
-  const sessionsDir = join(basePath, 'sessions');
-  if (!existsSync(sessionsDir)) return [];
-
-  const sessionFiles = findSessionFiles(sessionsDir);
-  const allSessions = [];
-
-  for (const filePath of sessionFiles) {
-    const exchanges = parseSessionFile(filePath);
-    if (exchanges.length === 0) continue;
-
-    const timestamps = exchanges
-      .map(e => e.userTimestamp)
-      .filter(Boolean)
-      .map(t => typeof t === 'number' ? t * 1000 : new Date(t).getTime())
-      .filter(t => !isNaN(t))
-      .sort();
-
-    const fileName = filePath.split('/').pop();
-
-    allSessions.push({
-      id: fileName.replace('.jsonl', ''),
-      file: fileName,
-      project: extractProjectName(filePath, exchanges),
-      exchanges,
-      turnCount: exchanges.length * 2,
-      exchangeCount: exchanges.length,
-      startTime: timestamps[0] ? new Date(timestamps[0]).toISOString() : null,
-      endTime: timestamps.length > 0 ? new Date(timestamps[timestamps.length - 1]).toISOString() : null,
-      durationMinutes: timestamps.length >= 2
-        ? Math.round((timestamps[timestamps.length - 1] - timestamps[0]) / 60000)
-        : 0,
-    });
-  }
-
-  return allSessions;
-}

package/src/parsers/cursor.js

@@ -1,281 +0,0 @@
-import { existsSync, readdirSync, statSync } from 'fs';
-import { join } from 'path';
-import { execSync } from 'child_process';
-
-/**
- * Parse Cursor chat history from SQLite state.vscdb files.
- *
- * Cursor stores chats in SQLite databases under:
- *   ~/Library/Application Support/Cursor/User/workspaceStorage/<hash>/state.vscdb
- *
- * Two storage formats exist:
- *   - Legacy: key = 'workbench.panel.aichat.view.aichat.chatdata' → JSON with tabs/bubbles
- *   - Current: key like 'composerData:%' in table cursorDiskKV → JSON with conversation data
- *     Bubble text stored separately under 'bubbleId:<composerId>:<bubbleId>'
- *
- * We normalize into the same session format as Claude Code.
- */
-
-function querySqlite(dbPath, query) {
-  try {
-    const result = execSync(
-      `sqlite3 -json "${dbPath}" "${query.replace(/"/g, '\\"')}"`,
-      { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
-    );
-    return JSON.parse(result || '[]');
-  } catch {
-    return [];
-  }
-}
-
-function querySqliteRaw(dbPath, query) {
-  try {
-    return execSync(
-      `sqlite3 "${dbPath}" "${query.replace(/"/g, '\\"')}"`,
-      { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
-    ).trim();
-  } catch {
-    return '';
-  }
-}
-
-/**
- * Try to detect which table the DB uses (ItemTable vs cursorDiskKV).
- */
-function detectTable(dbPath) {
-  const tables = querySqliteRaw(dbPath, ".tables");
-  if (tables.includes('cursorDiskKV')) return 'cursorDiskKV';
-  if (tables.includes('ItemTable')) return 'ItemTable';
-  return null;
-}
-
-/**
- * Parse legacy aichat format (tabs with bubbles inline).
- */
-function parseLegacyChat(dbPath, table) {
-  const raw = querySqliteRaw(
-    dbPath,
-    `SELECT value FROM ${table} WHERE key = 'workbench.panel.aichat.view.aichat.chatdata';`
-  );
-  if (!raw) return [];
-
-  try {
-    const data = JSON.parse(raw);
-    if (!data.tabs || !Array.isArray(data.tabs)) return [];
-
-    const sessions = [];
-    for (const tab of data.tabs) {
-      if (!tab.bubbles || !Array.isArray(tab.bubbles)) continue;
-
-      const exchanges = [];
-      let current = null;
-
-      for (const bubble of tab.bubbles) {
-        const text = bubble.text || '';
-        if (!text.trim()) continue;
-
-        // type 1 = user, type 2 = assistant
-        if (bubble.type === 1) {
-          if (current) exchanges.push(current);
-          current = {
-            userPrompt: text,
-            userTimestamp: bubble.createdAt || null,
-            assistantResponses: [],
-            toolCalls: [],
-            thinkingContent: [],
-          };
-        } else if (bubble.type === 2 && current) {
-          current.assistantResponses.push(text);
-          // Extract tool info if available
-          if (bubble.toolFormerData && Array.isArray(bubble.toolFormerData)) {
-            for (const tool of bubble.toolFormerData) {
-              current.toolCalls.push({ tool: tool.toolName || 'unknown', input: {} });
-            }
-          }
-        }
-      }
-      if (current) exchanges.push(current);
-      if (exchanges.length === 0) continue;
-
-      const timestamps = exchanges
-        .map(e => e.userTimestamp)
-        .filter(Boolean)
-        .map(t => new Date(t).getTime())
-        .sort();
-
-      sessions.push({
-        id: tab.tabId || `cursor-${sessions.length}`,
-        file: 'state.vscdb',
-        exchanges,
-        turnCount: exchanges.length * 2,
-        exchangeCount: exchanges.length,
-        startTime: timestamps[0] ? new Date(timestamps[0]).toISOString() : null,
-        endTime: timestamps.length > 0 ? new Date(timestamps[timestamps.length - 1]).toISOString() : null,
-        durationMinutes: timestamps.length >= 2
-          ? Math.round((timestamps[timestamps.length - 1] - timestamps[0]) / 60000)
-          : 0,
-      });
-    }
-    return sessions;
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Parse composer format (cursorDiskKV with separate bubble keys).
- */
-function parseComposerChat(dbPath) {
-  // Get all composer conversation metadata
-  const composerRows = querySqlite(
-    dbPath,
-    `SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%';`
-  );
-
-  if (!composerRows.length) return [];
-
-  const sessions = [];
-
-  for (const row of composerRows) {
-    try {
-      const composerData = JSON.parse(row.value || '{}');
-      const composerId = composerData.composerId || row.key.replace('composerData:', '');
-      const headers = composerData.fullConversationHeadersOnly || [];
-
-      if (headers.length === 0) continue;
-
-      const exchanges = [];
-      let current = null;
-
-      for (const header of headers) {
-        const bubbleKey = `bubbleId:${composerId}:${header.bubbleId}`;
-        const bubbleRaw = querySqliteRaw(
-          dbPath,
-          `SELECT value FROM cursorDiskKV WHERE key = '${bubbleKey}';`
-        );
-
-        if (!bubbleRaw) continue;
-
-        let bubbleData;
-        try {
-          bubbleData = JSON.parse(bubbleRaw);
-        } catch {
-          continue;
-        }
-
-        const text = bubbleData.text || '';
-        if (!text.trim()) continue;
-
-        // type 1 = user, type 2 = assistant
-        if (header.type === 1) {
-          if (current) exchanges.push(current);
-          current = {
-            userPrompt: text,
-            userTimestamp: bubbleData.createdAt || bubbleData.timingInfo?.startedAt || null,
-            assistantResponses: [],
-            toolCalls: [],
-            thinkingContent: [],
-          };
-        } else if (header.type === 2 && current) {
-          current.assistantResponses.push(text);
-          if (bubbleData.toolFormerData && Array.isArray(bubbleData.toolFormerData)) {
-            for (const tool of bubbleData.toolFormerData) {
-              current.toolCalls.push({ tool: tool.toolName || String(tool.tool || 'unknown'), input: {} });
-            }
-          }
-        }
-      }
-      if (current) exchanges.push(current);
-      if (exchanges.length === 0) continue;
-
-      const timestamps = exchanges
-        .map(e => e.userTimestamp)
-        .filter(Boolean)
-        .map(t => typeof t === 'number' ? t : new Date(t).getTime())
-        .sort();
-
-      sessions.push({
-        id: composerId,
-        file: 'state.vscdb',
-        exchanges,
-        turnCount: exchanges.length * 2,
-        exchangeCount: exchanges.length,
-        startTime: timestamps[0] ? new Date(timestamps[0]).toISOString() : null,
-        endTime: timestamps.length > 0 ? new Date(timestamps[timestamps.length - 1]).toISOString() : null,
-        durationMinutes: timestamps.length >= 2
-          ? Math.round((timestamps[timestamps.length - 1] - timestamps[0]) / 60000)
-          : 0,
-      });
-    } catch {
-      continue;
-    }
-  }
-
-  return sessions;
-}
-
-/**
- * Get workspace name from workspace.json.
- */
-function getWorkspaceName(workspaceDir) {
-  const wsFile = join(workspaceDir, 'workspace.json');
-  if (!existsSync(wsFile)) return workspaceDir.split('/').pop();
-  try {
-    const data = JSON.parse(execSync(`cat "${wsFile}"`, { encoding: 'utf-8' }));
-    // workspace.json has a "folder" field with the project path
-    const folder = data.folder || data.workspace || '';
-    // Extract meaningful project name from path
-    const decoded = decodeURIComponent(folder.replace('file://', ''));
-    const parts = decoded.split('/').filter(Boolean);
-    return parts.slice(-2).join('/') || workspaceDir.split('/').pop();
-  } catch {
-    return workspaceDir.split('/').pop();
-  }
-}
-
-/**
- * Parse all Cursor workspaces from workspaceStorage.
- */
-export function parseAllWorkspaces(basePath) {
-  if (!existsSync(basePath)) return [];
-
-  const allSessions = [];
-  let dirs;
-  try {
-    dirs = readdirSync(basePath).filter(f => {
-      try { return statSync(join(basePath, f)).isDirectory(); } catch { return false; }
-    });
-  } catch {
-    return [];
-  }
-
-  for (const dir of dirs) {
-    const workspaceDir = join(basePath, dir);
-    const dbPath = join(workspaceDir, 'state.vscdb');
-    if (!existsSync(dbPath)) continue;
-
-    const projectName = getWorkspaceName(workspaceDir);
-    const table = detectTable(dbPath);
-    if (!table) continue;
-
-    let sessions = [];
-
-    // Try composer format first (newer)
-    if (table === 'cursorDiskKV') {
-      sessions = parseComposerChat(dbPath);
-      // Also try legacy key in same table
-      if (sessions.length === 0) {
-        sessions = parseLegacyChat(dbPath, table);
-      }
-    } else {
-      sessions = parseLegacyChat(dbPath, table);
-    }
-
-    for (const session of sessions) {
-      session.project = projectName;
-      allSessions.push(session);
-    }
-  }
-
-  return allSessions;
-}

package/src/scorer.js

@@ -1,228 +0,0 @@
-/**
- * Combine individual metric scores into composite scores and assign archetype.
- *
- * Archetypes and tiers are consistent with the GitHub analysis system.
- * 15 archetypes across 5 tiers, mapped from repo-based signals to
- * prompt-behavior signals measured by the CLI.
- */
-
-// ── Tier thresholds (match GitHub analysis) ──
-
-const TIERS = [
-  { name: 'LEGENDARY',  min: 85, badge: '\uD83C\uDF1F\uD83C\uDF1F\uD83C\uDF1F', percentile: 'Top 1%' },
-  { name: 'ULTRA RARE', min: 73, badge: '\uD83C\uDF1F\uD83C\uDF1F',   percentile: 'Top 5%' },
-  { name: 'RARE',       min: 60, badge: '\u2B50',      percentile: 'Top 15%' },
-  { name: 'UNCOMMON',   min: 47, badge: '\u25C6',       percentile: 'Top 30%' },
-  { name: 'COMMON',     min: 0,  badge: '\u25CF',       percentile: 'Top 50%' },
-];
-
-// ── Archetype definitions ──
-
-const ARCHETYPES = [
-  // ── LEGENDARY (85+) ──
-  {
-    id: 'THE_10X_ENGINEER',
-    name: 'THE 10X ENGINEER',
-    tierRange: ['LEGENDARY'],
-    match: (s) => true,
-    priority: 1,
-    distribution: '< 1%',
-    description: 'Engineers classified as 10x demonstrate exceptional capability across all dimensions. They decompose complex systems methodically, debug with surgical precision, leverage AI as a strategic partner, and maintain disciplined workflows. This classification indicates mastery-level AI-augmented engineering.',
-    bestFor: 'CTO, founding engineer, or principal engineer roles requiring full-stack autonomy.',
-  },
-
-  // ── ULTRA RARE (73-84) ──
-  {
-    id: 'THE_ARCHITECT',
-    name: 'THE ARCHITECT',
-    tierRange: ['ULTRA RARE'],
-    match: (s) => s.decomposition >= 70 && s.sessionStructure >= 65,
-    priority: 2,
-    distribution: '3%',
-    description: 'Architects demonstrate exceptional problem decomposition paired with disciplined session structure. They think in systems, set context deliberately, and use AI for design-level decisions rather than line-level coding. Their sessions show a plan-first, build-second pattern.',
-    bestFor: 'Staff engineer, technical lead, or systems architect roles.',
-  },
-  {
-    id: 'THE_PROFESSOR',
-    name: 'THE PROFESSOR',
-    tierRange: ['ULTRA RARE'],
-    match: (s) => s.decomposition >= 65 && s.sessionStructure >= 70,
-    priority: 3,
-    distribution: '2%',
-    description: 'Professors combine deep analytical thinking with structured, pedagogical workflows. Their prompts read like detailed specifications. They set context meticulously and review output critically, treating AI as a collaborator that needs clear direction.',
-    bestFor: 'Technical leadership, developer education, or architecture review roles.',
-  },
-
-  // ── RARE (60-72) ──
-  {
-    id: 'THE_SPECIALIST',
-    name: 'THE SPECIALIST',
-    tierRange: ['RARE'],
-    match: (s) => s.debugCycles >= 70 && s.aiLeverage >= 65,
-    priority: 4,
-    distribution: '6%',
-    description: 'Specialists demonstrate deep expertise in targeted domains with precise, efficient debugging patterns and strategic AI tool usage. They favor depth over breadth and tend toward long, focused sessions on complex problems.',
-    bestFor: 'Senior engineer roles requiring deep domain expertise and autonomous execution.',
-  },
-  {
-    id: 'THE_SYSTEMS_THINKER',
-    name: 'THE SYSTEMS THINKER',
-    tierRange: ['RARE'],
-    match: (s) => s.decomposition >= 65 && s.sessionStructure >= 60,
-    priority: 5,
-    distribution: '5%',
-    description: 'Systems Thinkers break complex problems into well-structured components with deliberate context-setting. Their prompt patterns show they understand how parts connect to wholes, making them effective at designing and maintaining large systems.',
-    bestFor: 'Platform engineering, infrastructure, or technical architecture roles.',
-  },
-  {
-    id: 'THE_MAINTAINER',
-    name: 'THE MAINTAINER',
-    tierRange: ['RARE'],
-    match: (s) => s.sessionStructure >= 60 && s.debugCycles >= 60,
-    priority: 6,
-    distribution: '4%',
-    description: 'Maintainers combine reliable workflow discipline with solid debugging efficiency. They review before shipping, set context for each task, and resolve issues methodically. Their consistency makes them the backbone of production systems.',
-    bestFor: 'Senior engineer or tech lead roles where reliability and code quality are paramount.',
-  },
-
-  // ── UNCOMMON (47-59) ──
-  {
-    id: 'THE_CRAFTSPERSON',
-    name: 'THE CRAFTSPERSON',
-    tierRange: ['UNCOMMON'],
-    match: (s) => s.debugCycles >= 60 && s.sessionStructure >= 55,
-    priority: 7,
-    distribution: '8%',
-    description: 'Craftspeople show attention to quality through precise debugging and structured sessions. They may not yet operate at the architectural level, but their care for correctness and process indicates strong engineering foundations.',
-    bestFor: 'Mid-to-senior engineer roles focused on quality and reliability.',
-  },
-  {
-    id: 'THE_BUILDER',
-    name: 'THE BUILDER',
-    tierRange: ['UNCOMMON'],
-    match: (s) => {
-      const min = Math.min(s.decomposition, s.debugCycles, s.aiLeverage, s.sessionStructure);
-      return min >= 45;
-    },
-    priority: 8,
-    distribution: '10%',
-    description: 'Builders are well-rounded engineers with competence across all dimensions. No major weaknesses, no extreme spikes. They get things done consistently and adapt to different types of problems without over-specializing.',
-    bestFor: 'Full-stack or generalist engineer roles requiring versatility.',
-  },
-  {
-    id: 'THE_CONTRIBUTOR',
-    name: 'THE CONTRIBUTOR',
-    tierRange: ['UNCOMMON'],
-    match: (s) => s.aiLeverage >= 55 && s.decomposition >= 50,
-    priority: 9,
-    distribution: '7%',
-    description: 'Contributors show strong AI collaboration skills with good problem decomposition. They leverage AI effectively as a coding partner and break work into manageable pieces, though workflow discipline and debugging precision have room to grow.',
-    bestFor: 'Engineer roles in AI-forward teams with collaborative development practices.',
-  },
-  {
-    id: 'THE_HIDDEN_GEM',
-    name: 'THE HIDDEN GEM',
-    tierRange: ['UNCOMMON'],
-    match: (s) => (s.debugCycles >= 55 || s.aiLeverage >= 55) && s.sessionStructure < 50,
-    priority: 10,
-    distribution: '6%',
-    description: 'Hidden Gems demonstrate strong technical skills in debugging or AI leverage but lack workflow structure. They likely produce good output in bursts but could dramatically improve by adding session discipline. High ceiling, underdeveloped process.',
-    bestFor: 'Fast-moving startup roles where output matters more than process.',
-  },
-  {
-    id: 'THE_EXPLORER',
-    name: 'THE EXPLORER',
-    tierRange: ['UNCOMMON'],
-    match: (s) => s.aiLeverage >= 50,
-    priority: 11,
-    distribution: '9%',
-    description: 'Explorers are curiosity-driven engineers who use AI heavily for research, investigation, and learning. Their exploratory prompting shows intellectual breadth, though they may benefit from more structured approaches to execution.',
-    bestFor: 'R&D, prototyping, or innovation-focused engineer roles.',
-  },
-
-  // ── COMMON (0-46) ──
-  {
-    id: 'THE_TINKERER',
-    name: 'THE TINKERER',
-    tierRange: ['COMMON'],
-    match: (s) => s.debugCycles >= 40 && s.aiLeverage >= 35,
-    priority: 12,
-    distribution: '12%',
-    description: 'Tinkerers show practical problem-solving instincts with emerging AI skills. They debug adequately and are beginning to use AI beyond basic code generation, but all dimensions have significant room for growth.',
-    bestFor: 'Junior-to-mid engineer roles with growth opportunities.',
-  },
-  {
-    id: 'THE_GRINDER',
-    name: 'THE GRINDER',
-    tierRange: ['COMMON'],
-    match: (s) => s.decomposition >= 35,
-    priority: 13,
-    distribution: '11%',
-    description: 'Grinders are high-volume, iterative engineers. They keep going through problems with persistence. The volume of work is there but the approach could benefit from more strategic thinking and structured workflows.',
-    bestFor: 'Environments where persistence and volume are valued.',
-  },
-  {
-    id: 'THE_HOBBYIST',
-    name: 'THE HOBBYIST',
-    tierRange: ['COMMON'],
-    match: (s) => s.aiLeverage >= 30 || s.debugCycles >= 30,
-    priority: 14,
-    distribution: '10%',
-    description: 'Hobbyists are active but early in their AI-augmented engineering journey. They show some skill in debugging or AI usage but haven\'t yet developed consistent patterns across dimensions.',
-    bestFor: 'Early-career roles with mentorship and structured onboarding.',
-  },
-  {
-    id: 'THE_APPRENTICE',
-    name: 'THE APPRENTICE',
-    tierRange: ['COMMON'],
-    match: () => true,
-    priority: 99,
-    distribution: '7%',
-    description: 'Apprentices are at the beginning of their AI-augmented engineering practice. Their prompt patterns suggest they\'re still learning how to effectively collaborate with AI tools. Significant growth potential across all dimensions.',
-    bestFor: 'Entry-level roles with training programs and mentorship.',
-  },
-];
-
-export function computeOverallScore(metrics) {
-  const scores = {
-    decomposition: metrics.decomposition.score,
-    debugCycles: metrics.debugCycles.score,
-    aiLeverage: metrics.aiLeverage.score,
-    sessionStructure: metrics.sessionStructure.score,
-  };
-
-  // Weighted average
-  const overall = Math.round(
-    scores.decomposition * 0.25 +
-    scores.debugCycles * 0.25 +
-    scores.aiLeverage * 0.3 +
-    scores.sessionStructure * 0.2
-  );
-
-  // Assign tier first
-  const tier = TIERS.find(t => overall >= t.min) || TIERS[TIERS.length - 1];
-
-  // Assign archetype within tier
-  const tierArchetypes = ARCHETYPES
-    .filter(a => a.tierRange.includes(tier.name))
-    .sort((a, b) => a.priority - b.priority);
-
-  const archetype = tierArchetypes.find(a => a.match(scores))
-    || tierArchetypes[tierArchetypes.length - 1]
-    || ARCHETYPES[ARCHETYPES.length - 1];
-
-  return {
-    overall,
-    scores,
-    archetype: {
-      id: archetype.id,
-      name: archetype.name,
-      description: archetype.description,
-      distribution: archetype.distribution,
-      bestFor: archetype.bestFor,
-    },
-    tier: tier.name,
-    tierBadge: tier.badge,
-    tierPercentile: tier.percentile,
-  };
-}