@massu/core 1.10.8 → 1.12.1

package/src/transcript-parser.ts

@@ -1,458 +0,0 @@
-// Copyright (c) 2026 Massu. All rights reserved.
-// Licensed under BSL 1.1 - see LICENSE file for details.
-
-import { createReadStream } from 'fs';
-import { createInterface } from 'readline';
-
-// ============================================================
-// P2-001: JSONL Transcript Parser
-// ============================================================
-
-/**
- * Represents a parsed transcript entry.
- */
-export interface TranscriptEntry {
-  type: 'user' | 'assistant' | 'system' | 'progress' | 'summary' | 'file-history-snapshot' | 'unknown';
-  sessionId?: string;
-  gitBranch?: string;
-  timestamp?: string;
-  uuid?: string;
-  isMeta?: boolean;
-  message?: TranscriptMessage;
-  data?: Record<string, unknown>;
-}
-
-export interface TranscriptMessage {
-  role: 'user' | 'assistant' | 'system';
-  content: TranscriptContentBlock[];
-}
-
-export type TranscriptContentBlock =
-  | { type: 'text'; text: string }
-  | { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> }
-  | { type: 'tool_result'; tool_use_id: string; content: string | TranscriptContentBlock[]; is_error?: boolean }
-  | { type: string; [key: string]: unknown };
-
-/**
- * Parsed tool call with input and result linked.
- */
-export interface ParsedToolCall {
-  toolName: string;
-  toolUseId: string;
-  input: Record<string, unknown>;
-  result?: string;
-  isError?: boolean;
-  timestamp?: string;
-}
-
-/**
- * File operation extracted from tool calls.
- */
-export interface FileOperation {
-  type: 'read' | 'write' | 'edit' | 'glob' | 'grep' | 'delete';
-  filePath: string;
-  toolName: string;
-}
-
-/**
- * Extracted decision from assistant text.
- */
-export interface ExtractedDecision {
-  text: string;
-  context: string;
-}
-
-/**
- * Extracted failed attempt from assistant text.
- */
-export interface ExtractedFailedAttempt {
-  text: string;
-  context: string;
-}
-
-/**
- * Parse a JSONL transcript file line-by-line (streaming).
- * Handles 400MB+ files without loading entire file into memory.
- */
-export async function parseTranscript(filePath: string): Promise<TranscriptEntry[]> {
-  const entries: TranscriptEntry[] = [];
-
-  const rl = createInterface({
-    input: createReadStream(filePath, { encoding: 'utf-8' }),
-    crlfDelay: Infinity,
-  });
-
-  for await (const line of rl) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-
-    try {
-      const raw = JSON.parse(trimmed) as Record<string, unknown>;
-      const entry = parseEntry(raw);
-      if (entry) {
-        entries.push(entry);
-      }
-    } catch (_e) {
-      // Skip unparseable lines - defensive parsing
-      continue;
-    }
-  }
-
-  return entries;
-}
-
-/**
- * Parse a single JSONL entry into a TranscriptEntry.
- */
-function parseEntry(raw: Record<string, unknown>): TranscriptEntry | null {
-  const entryType = raw.type as string | undefined;
-  if (!entryType) return null;
-
-  const base: TranscriptEntry = {
-    type: (['user', 'assistant', 'system', 'progress', 'summary', 'file-history-snapshot'].includes(entryType)
-      ? entryType
-      : 'unknown') as TranscriptEntry['type'],
-    sessionId: raw.sessionId as string | undefined,
-    gitBranch: raw.gitBranch as string | undefined,
-    timestamp: raw.timestamp as string | undefined,
-    uuid: raw.uuid as string | undefined,
-  };
-
-  if (raw.isMeta) {
-    base.isMeta = true;
-  }
-
-  if (entryType === 'user' || entryType === 'assistant') {
-    const msgRaw = raw.message as Record<string, unknown> | undefined;
-    if (msgRaw) {
-      base.message = {
-        role: (msgRaw.role as string ?? entryType) as 'user' | 'assistant',
-        content: normalizeContent(msgRaw.content),
-      };
-    }
-  }
-
-  if (entryType === 'progress') {
-    base.data = raw.data as Record<string, unknown> | undefined;
-  }
-
-  return base;
-}
-
-/**
- * Normalize content to array of content blocks.
- */
-function normalizeContent(content: unknown): TranscriptContentBlock[] {
-  if (!content) return [];
-  if (typeof content === 'string') {
-    return [{ type: 'text', text: content }];
-  }
-  if (Array.isArray(content)) {
-    return content.filter((block): block is TranscriptContentBlock =>
-      typeof block === 'object' && block !== null && 'type' in block
-    );
-  }
-  return [];
-}
-
-// ============================================================
-// Extraction utilities
-// ============================================================
-
-/**
- * Extract all user messages from transcript entries.
- */
-export function extractUserMessages(entries: TranscriptEntry[]): Array<{ text: string; timestamp?: string }> {
-  const messages: Array<{ text: string; timestamp?: string }> = [];
-  for (const entry of entries) {
-    if (entry.type !== 'user' || !entry.message) continue;
-    // Skip meta/system messages
-    if (entry.isMeta) continue;
-
-    const text = getTextFromContent(entry.message.content);
-    if (text.trim()) {
-      messages.push({ text: text.trim(), timestamp: entry.timestamp });
-    }
-  }
-  return messages;
-}
-
-/**
- * Extract all assistant text messages.
- */
-export function extractAssistantMessages(entries: TranscriptEntry[]): Array<{ text: string; timestamp?: string }> {
-  const messages: Array<{ text: string; timestamp?: string }> = [];
-  for (const entry of entries) {
-    if (entry.type !== 'assistant' || !entry.message) continue;
-    const text = getTextFromContent(entry.message.content);
-    if (text.trim()) {
-      messages.push({ text: text.trim(), timestamp: entry.timestamp });
-    }
-  }
-  return messages;
-}
-
-/**
- * Extract all tool calls from transcript entries.
- */
-export function extractToolCalls(entries: TranscriptEntry[]): ParsedToolCall[] {
-  const toolCalls: ParsedToolCall[] = [];
-  const toolUseMap = new Map<string, ParsedToolCall>();
-
-  for (const entry of entries) {
-    if (!entry.message?.content) continue;
-
-    for (const block of entry.message.content) {
-      if (block.type === 'tool_use') {
-        const tc: ParsedToolCall = {
-          toolName: (block as { name: string }).name,
-          toolUseId: (block as { id: string }).id,
-          input: (block as { input: Record<string, unknown> }).input ?? {},
-          timestamp: entry.timestamp,
-        };
-        toolCalls.push(tc);
-        toolUseMap.set(tc.toolUseId, tc);
-      } else if (block.type === 'tool_result') {
-        const toolUseId = (block as { tool_use_id: string }).tool_use_id;
-        const existing = toolUseMap.get(toolUseId);
-        if (existing) {
-          existing.result = getToolResultText(block);
-          existing.isError = (block as { is_error?: boolean }).is_error ?? false;
-        }
-      }
-    }
-  }
-
-  return toolCalls;
-}
-
-/**
- * Extract file operations from tool calls.
- */
-export function extractFileOperations(toolCalls: ParsedToolCall[]): FileOperation[] {
-  const ops: FileOperation[] = [];
-
-  for (const tc of toolCalls) {
-    switch (tc.toolName) {
-      case 'Read': {
-        const filePath = tc.input.file_path as string;
-        if (filePath) ops.push({ type: 'read', filePath, toolName: 'Read' });
-        break;
-      }
-      case 'Write': {
-        const filePath = tc.input.file_path as string;
-        if (filePath) ops.push({ type: 'write', filePath, toolName: 'Write' });
-        break;
-      }
-      case 'Edit': {
-        const filePath = tc.input.file_path as string;
-        if (filePath) ops.push({ type: 'edit', filePath, toolName: 'Edit' });
-        break;
-      }
-      case 'Glob': {
-        ops.push({ type: 'glob', filePath: tc.input.pattern as string ?? '', toolName: 'Glob' });
-        break;
-      }
-      case 'Grep': {
-        ops.push({ type: 'grep', filePath: tc.input.path as string ?? '', toolName: 'Grep' });
-        break;
-      }
-    }
-  }
-
-  return ops;
-}
-
-/**
- * Extract verification commands from tool calls.
- */
-export function extractVerificationCommands(toolCalls: ParsedToolCall[]): Array<{
-  vrType: string;
-  command: string;
-  result: string;
-  passed: boolean;
-}> {
-  const verifications: Array<{
-    vrType: string;
-    command: string;
-    result: string;
-    passed: boolean;
-  }> = [];
-
-  for (const tc of toolCalls) {
-    if (tc.toolName !== 'Bash') continue;
-    const cmd = tc.input.command as string ?? '';
-    const result = tc.result ?? '';
-
-    // Pattern scanner
-    if (cmd.includes('pattern-scanner')) {
-      verifications.push({
-        vrType: 'VR-PATTERN',
-        command: cmd,
-        result: result.slice(0, 500),
-        passed: !result.includes('FAIL') && !result.includes('BLOCKED'),
-      });
-    }
-    // Build
-    if (cmd.includes('npm run build')) {
-      verifications.push({
-        vrType: 'VR-BUILD',
-        command: cmd,
-        result: result.slice(0, 500),
-        passed: !tc.isError && !result.includes('error'),
-      });
-    }
-    // Type check
-    if (cmd.includes('tsc --noEmit')) {
-      verifications.push({
-        vrType: 'VR-TYPE',
-        command: cmd,
-        result: result.slice(0, 500),
-        passed: !tc.isError && !result.includes('error'),
-      });
-    }
-    // Tests
-    if (cmd.includes('npm test') || cmd.includes('vitest run') || cmd.includes('vitest ')) {
-      verifications.push({
-        vrType: 'VR-TEST',
-        command: cmd,
-        result: result.slice(0, 500),
-        passed: !tc.isError && !result.includes('FAIL'),
-      });
-    }
-  }
-
-  return verifications;
-}
-
-/**
- * Extract decisions from assistant text (heuristic).
- */
-export function extractDecisions(entries: TranscriptEntry[]): ExtractedDecision[] {
-  const decisions: ExtractedDecision[] = [];
-  const decisionPatterns = /\b(decided|chose|chosen|decision|instead of|opted for|going with|approach:|strategy:)\b/i;
-
-  for (const entry of entries) {
-    if (entry.type !== 'assistant' || !entry.message) continue;
-    const text = getTextFromContent(entry.message.content);
-    if (!text) continue;
-
-    // Split into sentences/paragraphs
-    const paragraphs = text.split(/\n\n|\.\s+/);
-    for (const para of paragraphs) {
-      if (decisionPatterns.test(para) && para.length > 20 && para.length < 500) {
-        decisions.push({
-          text: para.trim().slice(0, 300),
-          context: text.slice(0, 200),
-        });
-      }
-    }
-  }
-
-  return decisions;
-}
-
-/**
- * Extract failed attempts from assistant text (heuristic).
- */
-export function extractFailedAttempts(entries: TranscriptEntry[]): ExtractedFailedAttempt[] {
-  const failures: ExtractedFailedAttempt[] = [];
-  const failurePatterns = /\b(error|failed|doesn't work|didn't work|reverted|rolled back|bug|broken|issue:|problem:)\b/i;
-
-  for (const entry of entries) {
-    if (entry.type !== 'assistant' || !entry.message) continue;
-    const text = getTextFromContent(entry.message.content);
-    if (!text) continue;
-
-    const paragraphs = text.split(/\n\n|\.\s+/);
-    for (const para of paragraphs) {
-      if (failurePatterns.test(para) && para.length > 20 && para.length < 500) {
-        failures.push({
-          text: para.trim().slice(0, 300),
-          context: text.slice(0, 200),
-        });
-      }
-    }
-  }
-
-  return failures;
-}
-
-/**
- * Parse a JSONL transcript file starting from a specific line (for incremental parsing).
- * Skips the first `startLine` lines and returns entries from the rest.
- */
-export async function parseTranscriptFrom(filePath: string, startLine: number): Promise<{ entries: TranscriptEntry[]; totalLines: number }> {
-  const entries: TranscriptEntry[] = [];
-  let lineNumber = 0;
-
-  const rl = createInterface({
-    input: createReadStream(filePath, { encoding: 'utf-8' }),
-    crlfDelay: Infinity,
-  });
-
-  for await (const line of rl) {
-    lineNumber++;
-    if (lineNumber <= startLine) continue;
-
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-
-    try {
-      const raw = JSON.parse(trimmed) as Record<string, unknown>;
-      const entry = parseEntry(raw);
-      if (entry) {
-        entries.push(entry);
-      }
-    } catch (_e) {
-      // Skip unparseable lines
-      continue;
-    }
-  }
-
-  return { entries, totalLines: lineNumber };
-}
-
-/**
- * Estimate token count for a text string.
- * Approximation: chars / 4.
- */
-export function estimateTokens(text: string): number {
-  return Math.ceil(text.length / 4);
-}
-
-/**
- * Get the last assistant message from entries (useful for session summaries).
- */
-export function getLastAssistantMessage(entries: TranscriptEntry[]): string | null {
-  for (let i = entries.length - 1; i >= 0; i--) {
-    if (entries[i].type === 'assistant' && entries[i].message) {
-      const text = getTextFromContent(entries[i].message!.content);
-      if (text.trim()) return text.trim();
-    }
-  }
-  return null;
-}
-
-// ============================================================
-// Helpers
-// ============================================================
-
-function getTextFromContent(content: TranscriptContentBlock[]): string {
-  return content
-    .filter((block): block is { type: 'text'; text: string } => block.type === 'text')
-    .map(block => block.text)
-    .join('\n');
-}
-
-function getToolResultText(block: TranscriptContentBlock): string {
-  const content = (block as { content: string | TranscriptContentBlock[] }).content;
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) {
-    return content
-      .filter((b): b is { type: 'text'; text: string } => typeof b === 'object' && b !== null && b.type === 'text')
-      .map(b => b.text)
-      .join('\n');
-  }
-  return '';
-}

package/src/trpc-index.ts

@@ -1,215 +0,0 @@
-// Copyright (c) 2026 Massu. All rights reserved.
-// Licensed under BSL 1.1 - see LICENSE file for details.
-
-import { readFileSync, existsSync, readdirSync } from 'fs';
-import { resolve, join } from 'path';
-import type Database from 'better-sqlite3';
-import { getConfig, getResolvedPaths, getProjectRoot } from './config.ts';
-import { t } from './lib/sql-table-names.ts';
-
-interface RouterMapping {
-  key: string;       // e.g., "orders" (used as api.orders.*)
-  variable: string;  // e.g., "ordersRouter"
-  file: string;      // e.g., "src/server/api/routers/orders.ts"
-}
-
-interface ProcedureInfo {
-  name: string;
-  type: 'query' | 'mutation';
-  isProtected: boolean;
-}
-
-/**
- * Parse src/server/api/root.ts to extract router key-to-file mapping.
- * The key is what UI code uses: api.[key].[procedure]
- */
-export function parseRootRouter(): RouterMapping[] {
-  const paths = getResolvedPaths();
-  const rootPath = paths.rootRouterPath;
-  if (!existsSync(rootPath)) {
-    throw new Error(`Root router not found at ${rootPath}`);
-  }
-
-  const source = readFileSync(rootPath, 'utf-8');
-  const mappings: RouterMapping[] = [];
-
-  // Step 1: Parse imports to map variable names to file paths
-  // import { ordersRouter } from './routers/orders'
-  const importMap = new Map<string, string>();
-  const importRegex = /import\s+\{[^}]*?(\w+Router)[^}]*\}\s+from\s+['"]\.\/routers\/([^'"]+)['"]/g;
-  let match;
-  while ((match = importRegex.exec(source)) !== null) {
-    const variable = match[1];
-    let filePath = match[2];
-    // Resolve to actual file path
-    const fullPath = resolve(paths.routersDir, filePath);
-    // Try with extensions
-    for (const ext of ['.ts', '.tsx', '']) {
-      const candidate = fullPath + ext;
-      const routersRelPath = getConfig().paths.routers ?? 'src/server/api/routers';
-      if (existsSync(candidate)) {
-        filePath = routersRelPath + '/' + filePath + ext;
-        break;
-      }
-      // Check if it's a directory with index
-      const indexCandidate = join(fullPath, 'index.ts');
-      if (existsSync(indexCandidate)) {
-        filePath = routersRelPath + '/' + filePath + '/index.ts';
-        break;
-      }
-    }
-    importMap.set(variable, filePath);
-  }
-
-  // Step 2: Parse router registration - "orders: ordersRouter"
-  const regRegex = /(\w+)\s*:\s*(\w+Router)/g;
-  while ((match = regRegex.exec(source)) !== null) {
-    const key = match[1];
-    const variable = match[2];
-    const file = importMap.get(variable);
-    if (file) {
-      mappings.push({ key, variable, file });
-    }
-  }
-
-  return mappings;
-}
-
-/**
- * Extract procedure definitions from a router file.
- */
-export function extractProcedures(routerFilePath: string): ProcedureInfo[] {
-  const absPath = resolve(getProjectRoot(), routerFilePath);
-  if (!existsSync(absPath)) return [];
-
-  const source = readFileSync(absPath, 'utf-8');
-  const procedures: ProcedureInfo[] = [];
-  const seen = new Set<string>();
-
-  // Pattern: procedureName: protectedProcedure or publicProcedure
-  const procRegex = /(\w+)\s*:\s*(protected|public)Procedure/g;
-  let match;
-  while ((match = procRegex.exec(source)) !== null) {
-    const name = match[1];
-    const isProtected = match[2] === 'protected';
-    if (seen.has(name)) continue;
-    seen.add(name);
-
-    // Determine if query or mutation by looking ahead
-    const afterMatch = source.slice(match.index);
-    const typeMatch = afterMatch.match(/\.(query|mutation)\s*\(/);
-    const type = typeMatch ? (typeMatch[1] as 'query' | 'mutation') : 'query';
-
-    procedures.push({ name, type, isProtected });
-  }
-
-  return procedures;
-}
-
-/**
- * Find UI call sites for a given router key and procedure name.
- */
-export function findUICallSites(routerKey: string, procedureName: string): { file: string; line: number; pattern: string }[] {
-  const callSites: { file: string; line: number; pattern: string }[] = [];
-  const config = getConfig();
-  const root = getProjectRoot();
-  const src = config.paths.source;
-  const searchDirs = [
-    resolve(root, config.paths.pages ?? (src + '/app')),
-    resolve(root, config.paths.components ?? (src + '/components')),
-    resolve(root, config.paths.hooks ?? (src + '/hooks')),
-  ];
-
-  const searchPattern = `api.${routerKey}.${procedureName}`;
-
-  for (const dir of searchDirs) {
-    if (!existsSync(dir)) continue;
-    searchDirectory(dir, searchPattern, callSites);
-  }
-
-  return callSites;
-}
-
-function searchDirectory(dir: string, pattern: string, results: { file: string; line: number; pattern: string }[]): void {
-  const entries = readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name === 'node_modules' || entry.name === '.next') continue;
-      searchDirectory(fullPath, pattern, results);
-    } else if (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx')) {
-      try {
-        const source = readFileSync(fullPath, 'utf-8');
-        const lines = source.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-          if (lines[i].includes(pattern)) {
-            const relPath = fullPath.slice(getProjectRoot().length + 1);
-            // Extract the full call pattern (e.g., api.orders.create.useMutation())
-            const lineContent = lines[i].trim();
-            const callMatch = lineContent.match(new RegExp(`(api\\.${escapeRegex(pattern.slice(4))}\\.[\\w.()]+)`));
-            results.push({
-              file: relPath,
-              line: i + 1,
-              pattern: callMatch ? callMatch[1] : pattern,
-            });
-          }
-        }
-      } catch {
-        // Skip unreadable files
-      }
-    }
-  }
-}
-
-function escapeRegex(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-/**
- * Build the full tRPC procedure index.
- * Stores results in massu_trpc_procedures and massu_trpc_call_sites tables.
- */
-export function buildTrpcIndex(dataDb: Database.Database): { totalProcedures: number; withCallers: number; withoutCallers: number } {
-  // Clear existing data
-  dataDb.exec(`DELETE FROM ${t('trpc_call_sites')}`);
-  dataDb.exec(`DELETE FROM ${t('trpc_procedures')}`);
-
-  const routerMappings = parseRootRouter();
-
-  const insertProc = dataDb.prepare(
-    `INSERT INTO ${t('trpc_procedures')} (router_file, router_name, procedure_name, procedure_type, has_ui_caller) VALUES (?, ?, ?, ?, ?)`
-  );
-  const insertCallSite = dataDb.prepare(
-    `INSERT INTO ${t('trpc_call_sites')} (procedure_id, file, line, call_pattern) VALUES (?, ?, ?, ?)`
-  );
-
-  let totalProcedures = 0;
-  let withCallers = 0;
-  let withoutCallers = 0;
-
-  const insertAll = dataDb.transaction(() => {
-    for (const router of routerMappings) {
-      const procedures = extractProcedures(router.file);
-
-      for (const proc of procedures) {
-        const callSites = findUICallSites(router.key, proc.name);
-        const hasUICaller = callSites.length > 0 ? 1 : 0;
-
-        const result = insertProc.run(router.file, router.key, proc.name, proc.type, hasUICaller);
-        const procId = result.lastInsertRowid;
-
-        for (const site of callSites) {
-          insertCallSite.run(procId, site.file, site.line, site.pattern);
-        }
-
-        totalProcedures++;
-        if (hasUICaller) withCallers++;
-        else withoutCallers++;
-      }
-    }
-  });
-
-  insertAll();
-
-  return { totalProcedures, withCallers, withoutCallers };
-}