aiwcli 0.12.2 → 0.12.3

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/transcript-loader.ts

@@ -0,0 +1,280 @@
+#!/usr/bin/env bun
+/**
+ * TranscriptLoader — Loads and formats transcript segments for deep reading.
+ *
+ * Given a session JSONL file path + optional line range, streams the file,
+ * filters to human-readable content (user + assistant messages), summarizes
+ * tool calls, and truncates to ~50K chars max.
+ *
+ * Usage:
+ *   bun transcript-loader.ts <jsonl-path>
+ *   bun transcript-loader.ts <jsonl-path> --lines=46-120
+ */
+
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { basename } from "path";
+import { MAX_LOADER_CHARS, type LoadedSegment } from "./types.js";
+import { logInfo, logWarn, logError } from "./logger.js";
+
+const HOOK_NAME = "rlm_loader";
+
+// ---------------------------------------------------------------------------
+// CLI entry
+// ---------------------------------------------------------------------------
+
+const args = process.argv.slice(2);
+const jsonlPath = args.find((a) => !a.startsWith("--"));
+const linesArg = args.find((a) => a.startsWith("--lines="));
+let lineRange: [number, number] | null = null;
+if (linesArg) {
+  const [start, end] = linesArg.split("=")[1].split("-").map(Number);
+  if (!isNaN(start) && !isNaN(end) && start >= 1 && end >= start) {
+    lineRange = [start, end];
+  }
+}
+
+if (jsonlPath && !process.env.RLM_LIB_MODE) {
+  loadTranscript(jsonlPath, lineRange)
+    .then((seg) => {
+      process.stdout.write(seg.content);
+      if (seg.truncated) {
+        logInfo(HOOK_NAME, "Output truncated at 50K chars", { stderr: true });
+      }
+    })
+    .catch((e) => {
+      logError(HOOK_NAME, `Load failed: ${e}`, { stderr: true });
+      process.exitCode = 1;
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Loader
+// ---------------------------------------------------------------------------
+
+async function loadTranscript(
+  filePath: string,
+  range: [number, number] | null = null,
+  maxChars: number = MAX_LOADER_CHARS,
+): Promise<LoadedSegment> {
+  const parts: string[] = [];
+  let totalChars = 0;
+  let truncated = false;
+  let lineNum = 0;
+  let sessionId = "";
+  let project = "";
+
+  const rl = createInterface({
+    input: createReadStream(filePath, { encoding: "utf-8" }),
+    crlfDelay: Infinity,
+  });
+
+  try {
+    for await (const line of rl) {
+      lineNum++;
+
+      // Skip lines outside range
+      if (range) {
+        if (lineNum < range[0]) continue;
+        if (lineNum > range[1]) break;
+      }
+
+      if (!line.trim()) continue;
+
+      let obj: Record<string, unknown>;
+      try {
+        obj = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      // Capture session metadata
+      if (!sessionId && obj.sessionId) {
+        sessionId = obj.sessionId as string;
+      }
+
+      const type = obj.type as string | undefined;
+      const timestamp = obj.timestamp as string | undefined;
+
+      if (type === "user") {
+        const msg = obj.message as Record<string, unknown> | undefined;
+        if (!msg) continue;
+        const content = extractContent(msg);
+        if (!content) continue;
+
+        const formatted = formatMessage("USER", timestamp, content);
+        if (totalChars + formatted.length > maxChars) {
+          truncated = true;
+          break;
+        }
+        parts.push(formatted);
+        totalChars += formatted.length;
+      } else if (type === "assistant") {
+        const msg = obj.message as Record<string, unknown> | undefined;
+        if (!msg) continue;
+        const { text, toolUses } = extractAssistantContent(msg);
+
+        if (text || toolUses.length > 0) {
+          const formatted = formatAssistantMessage(timestamp, text, toolUses);
+          if (totalChars + formatted.length > maxChars) {
+            truncated = true;
+            // Add what we can
+            const remaining = maxChars - totalChars;
+            if (remaining > 100) {
+              parts.push(formatted.slice(0, remaining) + "\n... [truncated]");
+            }
+            break;
+          }
+          parts.push(formatted);
+          totalChars += formatted.length;
+        }
+      }
+    }
+  } finally {
+    rl.close();
+  }
+
+  // Derive project from path
+  const pathParts = filePath.replace(/\\/g, "/").split("/");
+  const projectsIdx = pathParts.indexOf("projects");
+  if (projectsIdx >= 0 && projectsIdx + 1 < pathParts.length) {
+    project = pathParts[projectsIdx + 1];
+  }
+
+  return {
+    session_id: sessionId || basename(filePath, ".jsonl"),
+    project,
+    line_range: range,
+    content: parts.join("\n\n"),
+    truncated,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Content extraction
+// ---------------------------------------------------------------------------
+
+function extractContent(msg: Record<string, unknown>): string | null {
+  const content = msg.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const texts: string[] = [];
+    for (const block of content) {
+      if (typeof block === "string") {
+        texts.push(block);
+      } else if (typeof block === "object" && block !== null) {
+        const b = block as Record<string, unknown>;
+        if (b.type === "text" && typeof b.text === "string") {
+          texts.push(b.text);
+        }
+        // tool_result blocks — include short text content
+        if (b.type === "tool_result" && typeof b.content === "string") {
+          texts.push(`[Tool result: ${b.content.slice(0, 200)}]`);
+        }
+      }
+    }
+    return texts.length > 0 ? texts.join("\n") : null;
+  }
+  return null;
+}
+
+interface ToolUse {
+  name: string;
+  inputSummary: string;
+}
+
+function extractAssistantContent(msg: Record<string, unknown>): {
+  text: string;
+  toolUses: ToolUse[];
+} {
+  const content = msg.content;
+  let text = "";
+  const toolUses: ToolUse[] = [];
+
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    const texts: string[] = [];
+    for (const block of content) {
+      if (typeof block !== "object" || block === null) continue;
+      const b = block as Record<string, unknown>;
+      if (b.type === "text" && typeof b.text === "string") {
+        texts.push(b.text);
+      }
+      if (b.type === "tool_use") {
+        const name = (b.name as string) || "unknown";
+        const input = b.input as Record<string, unknown> | undefined;
+        toolUses.push({
+          name,
+          inputSummary: summarizeToolInput(name, input),
+        });
+      }
+    }
+    text = texts.join("\n");
+  }
+
+  return { text, toolUses };
+}
+
+function summarizeToolInput(toolName: string, input?: Record<string, unknown>): string {
+  if (!input) return "";
+  switch (toolName) {
+    case "Read":
+      return input.file_path ? `${input.file_path}` : "";
+    case "Write":
+      return input.file_path ? `${input.file_path}` : "";
+    case "Edit":
+      return input.file_path ? `${input.file_path}` : "";
+    case "Bash":
+      return input.command ? `${(input.command as string).slice(0, 80)}` : "";
+    case "Glob":
+      return input.pattern ? `${input.pattern}` : "";
+    case "Grep":
+      return input.pattern ? `/${input.pattern}/` : "";
+    case "Task":
+      return input.description ? `${input.description}` : "";
+    case "WebSearch":
+      return input.query ? `"${input.query}"` : "";
+    case "WebFetch":
+      return input.url ? `${input.url}` : "";
+    default:
+      return Object.keys(input).slice(0, 3).join(", ");
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+
+function formatMessage(role: string, timestamp: string | undefined, content: string): string {
+  const ts = timestamp ? `[${timestamp}]` : "";
+  return `--- ${role} ${ts} ---\n${content}`;
+}
+
+function formatAssistantMessage(
+  timestamp: string | undefined,
+  text: string,
+  toolUses: ToolUse[],
+): string {
+  const ts = timestamp ? `[${timestamp}]` : "";
+  const parts: string[] = [`--- ASSISTANT ${ts} ---`];
+
+  if (text) {
+    parts.push(text);
+  }
+
+  if (toolUses.length > 0) {
+    const toolLines = toolUses.map(
+      (t) => `  -> ${t.name}${t.inputSummary ? `: ${t.inputSummary}` : ""}`
+    );
+    parts.push("Tools used:\n" + toolLines.join("\n"));
+  }
+
+  return parts.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+export { loadTranscript };

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/transcript-searcher.ts

@@ -0,0 +1,274 @@
+#!/usr/bin/env bun
+/**
+ * TranscriptSearcher — Keyword/regex search over RLM session indexes.
+ *
+ * Reads cached index files one-at-a-time from ~/.claude/rlm-index/,
+ * scores each against query terms, and returns ranked results.
+ *
+ * Usage:
+ *   bun transcript-searcher.ts "plan review"
+ *   bun transcript-searcher.ts "plan review" --top=20
+ *   bun transcript-searcher.ts "plan review" --project=aiwcli
+ */
+
+import { readdir, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { logInfo, logWarn, logError, logDebug } from "./logger.js";
+
+const HOOK_NAME = "rlm_searcher";
+import {
+  CURRENT_SCHEMA_VERSION,
+  CLAUDE_PROJECTS_DIR,
+  RLM_INDEX_DIR,
+  TOP_N_HEAP,
+  WEIGHT,
+  type SessionIndex,
+  type SearchResult,
+  type IndexSegment,
+} from "./types.js";
+
+// ---------------------------------------------------------------------------
+// CLI entry
+// ---------------------------------------------------------------------------
+
+const args = process.argv.slice(2);
+const query = args.find((a) => !a.startsWith("--"));
+const topArg = args.find((a) => a.startsWith("--top="));
+const topN = topArg ? parseInt(topArg.split("=")[1], 10) : 10;
+const projectArg = args.find((a) => a.startsWith("--project="));
+const projectFilter = projectArg ? projectArg.split("=")[1] : null;
+
+if (query && !process.env.RLM_LIB_MODE) {
+  search(query, { topN, projectFilter })
+    .then((results) => {
+      if (typeof results === "string") {
+        logWarn(HOOK_NAME, results, { stderr: true });
+        process.exitCode = 1;
+      } else {
+        logInfo(HOOK_NAME, `Search returned ${results.length} results`);
+        process.stdout.write(JSON.stringify(results, null, 2) + "\n");
+      }
+    })
+    .catch((e) => {
+      logError(HOOK_NAME, `Search failed: ${e}`, { stderr: true });
+      process.exitCode = 1;
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Search
+// ---------------------------------------------------------------------------
+
+interface SearchOptions {
+  topN?: number;
+  projectFilter?: string | null;
+}
+
+async function search(
+  queryStr: string,
+  opts: SearchOptions = {},
+): Promise<SearchResult[] | string> {
+  const { topN = 10, projectFilter = null } = opts;
+
+  if (!existsSync(RLM_INDEX_DIR)) {
+    return "No indexes found. Run `/rlm:index` first to build the transcript index.";
+  }
+
+  const queryTerms = tokenize(queryStr);
+  if (queryTerms.length === 0) {
+    return "Query is empty after tokenization.";
+  }
+
+  // Build optional regex from query
+  let queryRegex: RegExp | null = null;
+  try {
+    queryRegex = new RegExp(queryStr, "i");
+  } catch {
+    // Not a valid regex — fall back to keyword-only matching
+  }
+
+  const heap: SearchResult[] = [];
+  let indexCount = 0;
+
+  let projectDirs: string[];
+  try {
+    projectDirs = await readdir(RLM_INDEX_DIR);
+  } catch {
+    return "Cannot read index directory.";
+  }
+
+  for (const project of projectDirs) {
+    if (projectFilter && !project.toLowerCase().includes(projectFilter.toLowerCase())) {
+      continue;
+    }
+
+    const projectPath = join(RLM_INDEX_DIR, project);
+    let files: string[];
+    try {
+      files = await readdir(projectPath);
+    } catch {
+      continue;
+    }
+
+    for (const file of files) {
+      if (!file.endsWith(".index.json")) continue;
+
+      let idx: SessionIndex;
+      try {
+        const raw = await readFile(join(projectPath, file), "utf-8");
+        idx = JSON.parse(raw) as SessionIndex;
+      } catch {
+        continue;
+      }
+
+      // Skip stale schema
+      if (idx.schema_version !== CURRENT_SCHEMA_VERSION) continue;
+
+      indexCount++;
+      const { score, matchingSegments } = scoreIndex(idx, queryTerms, queryRegex);
+
+      if (score > 0) {
+        const sessionId = file.replace(".index.json", "");
+        const sourcePath = join(CLAUDE_PROJECTS_DIR, project, `${sessionId}.jsonl`);
+        const result: SearchResult = {
+          session_id: idx.session_id || sessionId,
+          project: idx.project || project,
+          date: idx.date,
+          summary: idx.summary,
+          score,
+          matching_segments: matchingSegments,
+          source_path: sourcePath,
+          source_exists: existsSync(sourcePath),
+          index_path: join(projectPath, file),
+        };
+
+        insertSorted(heap, result, TOP_N_HEAP);
+      }
+    }
+  }
+
+  if (indexCount === 0) {
+    return "No indexes found. Run `/rlm:index` first to build the transcript index.";
+  }
+
+  return heap.slice(0, topN);
+}
+
+// ---------------------------------------------------------------------------
+// Scoring
+// ---------------------------------------------------------------------------
+
+/** Max segment score contribution per query term to prevent inflation. */
+const MAX_SEGMENT_HITS_PER_TERM = 2;
+
+function scoreIndex(
+  idx: SessionIndex,
+  queryTerms: string[],
+  queryRegex: RegExp | null,
+): { score: number; matchingSegments: IndexSegment[] } {
+  let score = 0;
+  const matchingSegments: IndexSegment[] = [];
+
+  for (const term of queryTerms) {
+    // Summary
+    if (idx.summary.toLowerCase().includes(term)) {
+      score += WEIGHT.summary;
+    }
+
+    // Keywords
+    for (const kw of idx.keywords) {
+      if (kw.includes(term)) {
+        score += WEIGHT.keywords;
+        break;
+      }
+    }
+
+    // Files touched
+    for (const f of idx.files_touched) {
+      if (f.toLowerCase().includes(term)) {
+        score += WEIGHT.filesTouched;
+        break;
+      }
+    }
+
+    // Commands
+    for (const cmd of idx.commands_run) {
+      if (cmd.toLowerCase().includes(term)) {
+        score += WEIGHT.commandsRun;
+        break;
+      }
+    }
+
+    // Tool calls
+    for (const tool of idx.tool_calls) {
+      if (tool.toLowerCase().includes(term)) {
+        score += WEIGHT.toolCalls;
+        break;
+      }
+    }
+
+    // Segments — score and collect matching, capped per term
+    let segHits = 0;
+    for (const seg of idx.segments) {
+      if (segHits >= MAX_SEGMENT_HITS_PER_TERM) break;
+      const segMatch =
+        seg.topic.toLowerCase().includes(term) ||
+        seg.keywords.some((k) => k.includes(term));
+      if (segMatch) {
+        score += WEIGHT.segmentTopic;
+        segHits++;
+        if (!matchingSegments.includes(seg)) {
+          matchingSegments.push(seg);
+        }
+      }
+    }
+  }
+
+  // Regex bonus on summary
+  if (queryRegex && queryRegex.test(idx.summary)) {
+    score += WEIGHT.summary * 0.5;
+  }
+
+  // Recency boost: sessions from last 7 days get 1.5x, last 30 days 1.2x
+  if (idx.first_timestamp) {
+    const ageMs = Date.now() - new Date(idx.first_timestamp).getTime();
+    if (!isNaN(ageMs)) {
+      const ageDays = ageMs / (1000 * 60 * 60 * 24);
+      if (ageDays < 7) score *= 1.5;
+      else if (ageDays < 30) score *= 1.2;
+    }
+  }
+
+  return { score, matchingSegments: matchingSegments.slice(0, 5) };
+}
+
+// ---------------------------------------------------------------------------
+// Tokenization
+// ---------------------------------------------------------------------------
+
+function tokenize(query: string): string[] {
+  return query
+    .toLowerCase()
+    .split(/\s+/)
+    .map((t) => t.replace(/[^a-z0-9_-]/g, ""))
+    .filter((t) => t.length >= 2);
+}
+
+// ---------------------------------------------------------------------------
+// Sorted insertion (descending by score, capped at maxSize)
+// ---------------------------------------------------------------------------
+
+function insertSorted(arr: SearchResult[], item: SearchResult, maxSize: number): void {
+  // Find insertion point (descending order)
+  let i = 0;
+  while (i < arr.length && arr[i].score >= item.score) i++;
+  arr.splice(i, 0, item);
+  if (arr.length > maxSize) arr.pop();
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+export { search, scoreIndex, tokenize, type SearchOptions };