preflight-dev 3.1.0

package/src/tools/session-stats.ts

@@ -0,0 +1,134 @@
+// =============================================================================
+// session_stats — Lightweight JSONL session analysis (no embeddings needed)
+// =============================================================================
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+interface SessionInfo {
+  file: string;
+  turns: number;
+  corrections: number;
+  compactions: number;
+}
+
+async function findSessionFiles(): Promise<string[]> {
+  const baseDir = join(homedir(), ".claude", "projects");
+  const files: string[] = [];
+
+  async function walk(dir: string): Promise<void> {
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(full);
+        } else if (entry.name.endsWith(".jsonl")) {
+          files.push(full);
+        }
+      }
+    } catch {
+      // skip inaccessible dirs
+    }
+  }
+
+  await walk(baseDir);
+  return files;
+}
+
+async function analyzeSession(filePath: string): Promise<SessionInfo> {
+  const content = await readFile(filePath, "utf-8");
+  const lines = content.trim().split("\n").filter(Boolean);
+  let turns = 0;
+  let corrections = 0;
+  let compactions = 0;
+
+  for (const line of lines) {
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === "human" || obj.role === "human" || obj.role === "user") {
+        turns++;
+      }
+      // Detect corrections: messages containing "no", "wrong", "actually", "instead"
+      const text = (obj.message || obj.content || "").toString().toLowerCase();
+      if (turns > 0 && /\b(no[,.]|wrong|actually|instead|that's not|not what i)\b/.test(text)) {
+        corrections++;
+      }
+      // Detect compactions
+      if (obj.type === "summary" || obj.type === "compaction" || text.includes("compacted") || text.includes("context window")) {
+        compactions++;
+      }
+    } catch {
+      // skip malformed lines
+    }
+  }
+
+  return { file: filePath, turns, corrections, compactions };
+}
+
+export function registerSessionStats(server: McpServer): void {
+  server.tool(
+    "session_stats",
+    "Analyze Claude Code session history from JSONL files. Returns total sessions, prompts, correction rate, and more. No embeddings needed.",
+    {
+      projectFilter: z.string().optional().describe("Filter to sessions matching this project path substring"),
+    },
+    async ({ projectFilter }) => {
+      const files = await findSessionFiles();
+      const filtered = projectFilter
+        ? files.filter((f) => f.includes(projectFilter))
+        : files;
+
+      if (filtered.length === 0) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: "No session files found in ~/.claude/projects/",
+            },
+          ],
+        };
+      }
+
+      const sessions = await Promise.all(filtered.map(analyzeSession));
+      const totalTurns = sessions.reduce((s, x) => s + x.turns, 0);
+      const totalCorrections = sessions.reduce((s, x) => s + x.corrections, 0);
+      const totalCompactions = sessions.reduce((s, x) => s + x.compactions, 0);
+      const avgTurns = sessions.length > 0 ? (totalTurns / sessions.length).toFixed(1) : "0";
+      const correctionRate = totalTurns > 0 ? ((totalCorrections / totalTurns) * 100).toFixed(1) : "0";
+
+      // Find most active branches (group by parent dir)
+      const branchCounts = new Map<string, number>();
+      for (const s of sessions) {
+        const parts = s.file.split("/");
+        const branch = parts.slice(-2, -1)[0] || "unknown";
+        branchCounts.set(branch, (branchCounts.get(branch) || 0) + s.turns);
+      }
+      const topBranches = [...branchCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([name, count]) => `  ${name}: ${count} prompts`)
+        .join("\n");
+
+      const report = [
+        `📊 Session Stats`,
+        `────────────────────────`,
+        `Sessions:        ${sessions.length}`,
+        `Total prompts:   ${totalTurns}`,
+        `Corrections:     ${totalCorrections} (${correctionRate}% rate)`,
+        `Compactions:     ${totalCompactions}`,
+        `Avg session len: ${avgTurns} turns`,
+        ``,
+        `Most active branches:`,
+        topBranches || "  (none)",
+      ].join("\n");
+
+      return {
+        content: [{ type: "text" as const, text: report }],
+      };
+    }
+  );
+}

package/src/tools/sharpen-followup.ts

@@ -0,0 +1,200 @@
+// CATEGORY 4: sharpen_followup — Follow-up Specificity
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { run } from "../lib/git.js";
+import { now } from "../lib/state.js";
+
+/** Parse git porcelain output into deduplicated file paths, handling renames (R/C) */
+function parsePortelainFiles(output: string): string[] {
+  if (!output.trim()) return [];
+  const files = new Set<string>();
+  for (const line of output.split("\n").filter(Boolean)) {
+    if (line.length < 4) continue;
+    const status = line.slice(0, 2);
+    const rest = line.slice(3);
+    if (status.startsWith("R") || status.startsWith("C")) {
+      // "R  old -> new" — include both old and new
+      const parts = rest.split(" -> ");
+      parts.forEach((p) => { const t = p.trim(); if (t) files.add(t); });
+    } else {
+      const t = rest.trim();
+      if (t) files.add(t);
+    }
+  }
+  return [...files];
+}
+
+/** Get recently changed files, safe for first commit / shallow clones */
+function getRecentChangedFiles(): string[] {
+  // Try HEAD~1..HEAD, fall back to just staged, then unstaged
+  const commands = [
+    "git diff --name-only HEAD~1 HEAD 2>/dev/null",
+    "git diff --name-only --cached 2>/dev/null",
+    "git diff --name-only 2>/dev/null",
+  ];
+  const results = new Set<string>();
+  for (const cmd of commands) {
+    const out = run(cmd);
+    if (out) out.split("\n").filter(Boolean).forEach((f) => results.add(f));
+    if (results.size > 0) break; // first successful source is enough
+  }
+  return [...results];
+}
+
+export function registerSharpenFollowup(server: McpServer): void {
+  server.tool(
+    "sharpen_followup",
+    `Detects vague follow-up prompts and sharpens them with specific files, scope, and context from previous actions and git state. Call when the user says things like "fix it", "do the same for the others", "now the tests" without specifying files or scope.`,
+    {
+      followup_message: z.string().describe("The user's follow-up message to analyze"),
+      previous_action: z.string().describe("Description of what was just done"),
+      previous_files: z.array(z.string()).optional().describe("Files involved in the previous action"),
+    },
+    async ({ followup_message, previous_action, previous_files }) => {
+      const msg = followup_message.trim();
+      const assumptions: string[] = [];
+      const questions: string[] = [];
+      let confidence: "high" | "medium" | "low" = "high";
+
+      // Vagueness detection
+      const pronounPattern = /\b(it|them|this|that|those|the others?|these)\b/gi;
+      const scopePattern = /\b(all|everything|the rest|everywhere|each one|every)\b/gi;
+      const hasPathRef = /[\/\\]|\.(?:ts|js|tsx|jsx|py|rs|go|md|json|yaml|yml|toml|css|html|sh)\b/.test(msg);
+      const isBareCommand = msg.length < 30 && !hasPathRef;
+
+      const pronounMatches = [...new Set([...msg.matchAll(pronounPattern)].map(m => m[0].toLowerCase()))];
+      const scopeMatches = [...new Set([...msg.matchAll(scopePattern)].map(m => m[0].toLowerCase()))];
+
+      const vagueSignals: string[] = [];
+      if (pronounMatches.length > 0) vagueSignals.push(`pronouns without antecedents: ${pronounMatches.join(", ")}`);
+      if (scopeMatches.length > 0) vagueSignals.push(`scope words without specifics: ${scopeMatches.join(", ")}`);
+      if (isBareCommand) vagueSignals.push("bare command with no file/path reference");
+
+      // If no vagueness detected, pass through
+      if (vagueSignals.length === 0) {
+        const output = [
+          "## Follow-up Analysis",
+          "",
+          `**Original:** ${msg}`,
+          `**Sharpened:** ${msg}`,
+          `**Confidence:** high`,
+          "",
+          "_Follow-up is already specific enough — no changes needed._",
+        ].join("\n");
+        return { content: [{ type: "text" as const, text: output }] };
+      }
+
+      // Gather context to resolve ambiguity
+      const contextFiles: string[] = [...(previous_files ?? [])];
+      const recentChanged = getRecentChangedFiles();
+      const porcelainOutput = run("git status --porcelain 2>/dev/null");
+      const untrackedOrModified = parsePortelainFiles(porcelainOutput);
+
+      const allKnownFiles = [...new Set([...contextFiles, ...recentChanged, ...untrackedOrModified])].filter(Boolean);
+
+      let sharpened = msg;
+
+      // Resolve singular pronouns: "it" / "this" / "that"
+      const singularPronouns = pronounMatches.filter(p => ["it", "this", "that"].includes(p));
+      if (singularPronouns.length > 0) {
+        if (contextFiles.length === 1) {
+          for (const p of singularPronouns) {
+            sharpened = sharpened.replace(new RegExp(`\\b${p}\\b`, "i"), contextFiles[0]);
+          }
+          assumptions.push(`Resolved ${singularPronouns.map(p => `"${p}"`).join(", ")} → ${contextFiles[0]} (only file from previous action)`);
+        } else if (contextFiles.length > 1) {
+          confidence = "low";
+          questions.push(`Which file do you mean? Previous action touched: ${contextFiles.join(", ")}`);
+        } else if (recentChanged.length === 1) {
+          for (const p of singularPronouns) {
+            sharpened = sharpened.replace(new RegExp(`\\b${p}\\b`, "i"), recentChanged[0]);
+          }
+          assumptions.push(`Resolved ${singularPronouns.map(p => `"${p}"`).join(", ")} → ${recentChanged[0]} (only recent git change)`);
+          confidence = "medium";
+        } else {
+          confidence = "low";
+          questions.push("Which file or component are you referring to? No single obvious target found.");
+        }
+      }
+
+      // Resolve plural pronouns: "them" / "the others" / "these" / "those"
+      const pluralPronouns = pronounMatches.filter(p => ["them", "the others", "those", "these"].includes(p));
+      if (pluralPronouns.length > 0) {
+        const otherFiles = allKnownFiles.filter(f => !contextFiles.slice(0, 1).includes(f));
+        if (otherFiles.length > 0 && otherFiles.length <= 10) {
+          for (const p of pluralPronouns) {
+            sharpened = sharpened.replace(new RegExp(`\\b${p.replace(/\s+/g, "\\s+")}\\b`, "i"), otherFiles.join(", "));
+          }
+          assumptions.push(`Resolved ${pluralPronouns.map(p => `"${p}"`).join(", ")} → remaining files: ${otherFiles.join(", ")}`);
+          confidence = otherFiles.length <= 3 ? "medium" : "low";
+        } else if (otherFiles.length > 10) {
+          confidence = "low";
+          questions.push(`Found ${otherFiles.length} candidate files — too many to assume. Which subset do you mean?`);
+        } else {
+          confidence = "low";
+          questions.push('What does "the others" refer to? No additional files found in context.');
+        }
+      }
+
+      // Resolve scope words
+      if (scopeMatches.length > 0 && !hasPathRef) {
+        if (allKnownFiles.length > 0 && allKnownFiles.length <= 8) {
+          assumptions.push(`Scope "${scopeMatches[0]}" interpreted as: ${allKnownFiles.join(", ")}`);
+          confidence = confidence === "high" ? "medium" : "low";
+        } else if (allKnownFiles.length > 8) {
+          confidence = "low";
+          questions.push(`"${scopeMatches[0]}" is ambiguous — ${allKnownFiles.length} files in scope. Please specify a directory or glob pattern.`);
+        } else {
+          confidence = "low";
+          questions.push(`What does "${scopeMatches[0]}" cover? No files found in recent context.`);
+        }
+      }
+
+      // Bare command enrichment
+      if (isBareCommand && contextFiles.length > 0) {
+        sharpened = `${sharpened} in ${contextFiles.join(", ")}`;
+        assumptions.push(`Added file scope from previous action: ${contextFiles.join(", ")}`);
+        if (confidence === "high") confidence = "medium";
+      }
+
+      // Build markdown output
+      const lines = [
+        "## Follow-up Analysis",
+        "",
+        `**Original:** ${msg}`,
+        `**Sharpened:** ${confidence === "low" && questions.length > 0 ? "(needs clarification)" : sharpened}`,
+        `**Confidence:** ${confidence}`,
+        `**Previous action:** ${previous_action}`,
+        "",
+      ];
+
+      if (vagueSignals.length > 0) {
+        lines.push("### Vague Signals Detected");
+        vagueSignals.forEach((s) => lines.push(`- ⚠️ ${s}`));
+        lines.push("");
+      }
+
+      if (assumptions.length > 0) {
+        lines.push("### Assumptions Made");
+        assumptions.forEach((a) => lines.push(`- ${a}`));
+        lines.push("");
+      }
+
+      if (questions.length > 0) {
+        lines.push("### Clarifying Questions");
+        questions.forEach((q) => lines.push(`- ❓ ${q}`));
+        lines.push("");
+      }
+
+      if (allKnownFiles.length > 0) {
+        lines.push("### Available Context Files");
+        allKnownFiles.slice(0, 20).forEach((f) => lines.push(`- \`${f}\``));
+        lines.push("");
+      }
+
+      lines.push(`_Generated ${now()}_`);
+
+      return { content: [{ type: "text" as const, text: lines.join("\n") }] };
+    }
+  );
+}

package/src/tools/timeline-view.ts

@@ -0,0 +1,181 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { getTimeline, listIndexedProjects } from "../lib/timeline-db.js";
+import { getRelatedProjects } from "../lib/config.js";
+import type { SearchScope } from "../types.js";
+
+const RELATIVE_DATE_RE = /^(\d+)(days?|weeks?|months?|years?)$/;
+
+function parseRelativeDate(input: string): string {
+  const match = input.match(RELATIVE_DATE_RE);
+  if (!match) return input;
+  const [, numStr, unit] = match;
+  const num = parseInt(numStr, 10);
+  const d = new Date();
+  if (unit.startsWith("day")) d.setDate(d.getDate() - num);
+  else if (unit.startsWith("week")) d.setDate(d.getDate() - num * 7);
+  else if (unit.startsWith("month")) d.setMonth(d.getMonth() - num);
+  else if (unit.startsWith("year")) d.setFullYear(d.getFullYear() - num);
+  return d.toISOString();
+}
+
+const TYPE_ICONS: Record<string, string> = {
+  prompt: "💬",
+  assistant: "🤖",
+  tool_call: "🔧",
+  correction: "❌",
+  commit: "📦",
+  compaction: "🗜️",
+  sub_agent_spawn: "🚀",
+  error: "⚠️",
+};
+
+/** Get project directories to search based on scope */
+async function getSearchProjects(scope: SearchScope): Promise<string[]> {
+  const currentProject = process.env.CLAUDE_PROJECT_DIR;
+  
+  switch (scope) {
+    case "current":
+      return currentProject ? [currentProject] : [];
+      
+    case "related":
+      const related = getRelatedProjects();
+      return currentProject ? [currentProject, ...related] : related;
+      
+    case "all":
+      const projects = await listIndexedProjects();
+      return projects.map(p => p.project);
+      
+    default:
+      return currentProject ? [currentProject] : [];
+  }
+}
+
+export function registerTimeline(server: McpServer) {
+  server.tool(
+    "timeline",
+    "Chronological view of project events grouped by day. Shows prompts, responses, tool calls, corrections, and commits in order.",
+    {
+      scope: z.enum(["current", "related", "all"]).default("current").describe("Search scope: current project, related projects (PREFLIGHT_RELATED), or all indexed projects"),
+      project: z.string().optional().describe("Filter to a specific project name (overrides scope)"),
+      branch: z.string().optional(),
+      author: z.string().optional().describe("Filter commits to this author (partial match, case-insensitive)"),
+      since: z.string().optional(),
+      until: z.string().optional(),
+      type: z.enum(["prompt", "assistant", "correction", "commit", "tool_call", "compaction", "sub_agent_spawn", "error", "all"]).default("all"),
+      limit: z.number().default(50),
+      offset: z.number().default(0),
+    },
+    async (params) => {
+      const since = params.since ? parseRelativeDate(params.since) : undefined;
+      const until = params.until ? parseRelativeDate(params.until) : undefined;
+
+      // Determine which projects to search
+      let projectDirs: string[];
+      if (params.project) {
+        // Specific project overrides scope
+        projectDirs = [params.project];
+      } else {
+        projectDirs = await getSearchProjects(params.scope);
+      }
+
+      if (projectDirs.length === 0) {
+        return { 
+          content: [{ 
+            type: "text", 
+            text: `## Timeline\n_No projects found for scope "${params.scope}". Make sure CLAUDE_PROJECT_DIR is set or projects are onboarded._` 
+          }] 
+        };
+      }
+
+      let events = await getTimeline({
+        project_dirs: projectDirs,
+        project: undefined, // Don't filter by single project when using project_dirs
+        branch: params.branch,
+        since,
+        until,
+        type: params.type === "all" ? undefined : params.type,
+        limit: params.limit,
+        offset: params.offset,
+      });
+
+      // Post-filter by author
+      if (params.author) {
+        const authorLower = params.author.toLowerCase();
+        events = events.filter((e: any) => {
+          if (e.type !== "commit") return true; // only filter commits
+          try {
+            const meta = JSON.parse(e.metadata || "{}");
+            return (meta.author || "").toLowerCase().includes(authorLower);
+          } catch { return true; }
+        });
+      }
+
+      if (events.length === 0) {
+        return { content: [{ type: "text", text: "## Timeline\n_No events found for the given filters._" }] };
+      }
+
+      // Group by day
+      const days = new Map<string, any[]>();
+      for (const event of events) {
+        const day = event.timestamp ? new Date(event.timestamp).toISOString().slice(0, 10) : "unknown";
+        if (!days.has(day)) days.set(day, []);
+        days.get(day)!.push(event);
+      }
+
+      // Header
+      const proj = params.project || "all projects";
+      const branch = params.branch ? ` / ${params.branch}` : "";
+      const sortedDays = [...days.keys()].sort().reverse();
+      const dateRange = sortedDays.length > 1
+        ? `${sortedDays[sortedDays.length - 1]} to ${sortedDays[0]}`
+        : sortedDays[0];
+
+      const lines: string[] = [
+        `## Timeline: ${proj}${branch}`,
+        `_${dateRange} (${events.length} events)_`,
+        "",
+      ];
+
+      for (const day of sortedDays) {
+        lines.push(`### ${day}`);
+        const dayEvents = days.get(day)!;
+        // Sort by timestamp within day
+        dayEvents.sort((a: any, b: any) => {
+          const ta = a.timestamp ? new Date(a.timestamp).getTime() : 0;
+          const tb = b.timestamp ? new Date(b.timestamp).getTime() : 0;
+          return ta - tb;
+        });
+
+        for (const event of dayEvents) {
+          const time = event.timestamp
+            ? new Date(event.timestamp).toISOString().slice(11, 16)
+            : "??:??";
+          const icon = TYPE_ICONS[event.type] || "❓";
+          let content = (event.content || event.summary || "").slice(0, 120).replace(/\n/g, " ");
+
+          // Format based on type
+          if (event.type === "commit") {
+            const hash = event.commit_hash ? event.commit_hash.slice(0, 7) + ": " : "";
+            content = `commit: "${hash}${content}"`;
+          } else if (event.type === "tool_call") {
+            const tool = event.tool_name || "";
+            const target = content ? ` → ${content}` : "";
+            content = `${tool}${target}`;
+          } else {
+            content = `"${content}"`;
+          }
+
+          lines.push(`- ${time} ${icon} ${content}`);
+        }
+        lines.push("");
+      }
+
+      if (events.length === params.limit) {
+        lines.push(`_Showing ${params.limit} events (offset ${params.offset}). Use offset=${params.offset + params.limit} for more._`);
+      }
+
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+}