@massu/core 0.1.0 → 0.1.2

package/src/transcript-parser.ts

@@ -0,0 +1,458 @@
+// 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

@@ -0,0 +1,214 @@
+// 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';
+
+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 massu_trpc_call_sites');
+  dataDb.exec('DELETE FROM massu_trpc_procedures');
+
+  const routerMappings = parseRootRouter();
+
+  const insertProc = dataDb.prepare(
+    'INSERT INTO massu_trpc_procedures (router_file, router_name, procedure_name, procedure_type, has_ui_caller) VALUES (?, ?, ?, ?, ?)'
+  );
+  const insertCallSite = dataDb.prepare(
+    'INSERT INTO massu_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 };
+}