rewound 0.2.0

package/dist/mcp.js

@@ -0,0 +1,192 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { search, collapseSnippetWhitespace } from "./search.js";
+import { getSessionByIdOrPrefix, getMessagesForSession, parseJsonStringArray, hasAnyMessages } from "./db.js";
+const MAX_RESPONSE_BYTES = 8192;
+const EXCERPT_CHARS = 700;
+const SUMMARY_TEXT_CHARS = 500;
+const DEFAULT_SEARCH_LIMIT = 5;
+const MAX_SEARCH_LIMIT = 20;
+const DEFAULT_EXCERPT_CONTEXT = 3;
+const MAX_EXCERPT_CONTEXT = 20;
+function truncate(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return text.slice(0, maxChars) + "…";
+}
+// Windows `text` to `maxChars` centered on the first query term found in it (case-
+// insensitive substring search), so a hit whose match falls past `maxChars` still shows
+// the match instead of unrelated leading text. FTS5 uses porter stemming, so a query term
+// may not appear verbatim (e.g. "trigger" matching stored "triggers") — falls back to a
+// leading truncate() in that case, same as before this existed.
+function centeredExcerpt(text, query, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const lowerText = text.toLowerCase();
+    let matchIndex = -1;
+    for (const term of query.trim().split(/\s+/).filter(Boolean)) {
+        const idx = lowerText.indexOf(term.toLowerCase());
+        if (idx !== -1 && (matchIndex === -1 || idx < matchIndex))
+            matchIndex = idx;
+    }
+    if (matchIndex === -1)
+        return truncate(text, maxChars);
+    const half = Math.floor(maxChars / 2);
+    const start = Math.max(0, Math.min(matchIndex - half, text.length - maxChars));
+    const end = start + maxChars;
+    const prefix = start > 0 ? "…" : "";
+    const suffix = end < text.length ? "…" : "";
+    return prefix + text.slice(start, end) + suffix;
+}
+// Byte-safe truncation for the joinWithinBudget backstop below: char-level truncate()
+// already keeps normal content well under budget, this only fires as a last resort.
+function truncateBytes(text, maxBytes) {
+    const buf = Buffer.from(text, "utf8");
+    if (buf.byteLength <= maxBytes)
+        return text;
+    return buf.subarray(0, Math.max(0, maxBytes - 1)).toString("utf8") + "…";
+}
+// Joins parts with `separator`, dropping trailing parts (and noting it) once the
+// joined text would exceed `budgetBytes` — keeps any single MCP response bounded
+// regardless of how many hits/messages matched. Callers should already truncate
+// each part to a sane char length; this also hard-truncates a lone first part that
+// alone exceeds the budget, so the cap holds even if a caller forgets to.
+function joinWithinBudget(parts, separator, budgetBytes) {
+    const kept = [];
+    let usedBytes = 0;
+    let truncated = false;
+    for (const part of parts) {
+        const partBytes = Buffer.byteLength(part, "utf8");
+        if (kept.length === 0 && partBytes > budgetBytes) {
+            kept.push(truncateBytes(part, budgetBytes));
+            truncated = true;
+            break;
+        }
+        const additional = partBytes + (kept.length > 0 ? Buffer.byteLength(separator, "utf8") : 0);
+        if (kept.length > 0 && usedBytes + additional > budgetBytes) {
+            truncated = true;
+            break;
+        }
+        kept.push(part);
+        usedBytes += additional;
+    }
+    const joined = kept.join(separator);
+    return truncated ? `${joined}${separator}…(response truncated to stay under ~${budgetBytes} bytes)` : joined;
+}
+function textResult(text, isError = false) {
+    return { content: [{ type: "text", text }], isError };
+}
+export function createMcpServer(db) {
+    const server = new McpServer({ name: "rewound", version: "0.1.0" });
+    server.registerTool("search_history", {
+        description: "Full-text search over past AI coding agent session transcripts on this machine. " +
+            "Returns ranked excerpts with session id/title/date; use get_session_excerpt for more context around a hit.",
+        inputSchema: {
+            query: z.string().min(1).describe("Search terms (plain words, matched as an AND of terms)"),
+            project: z.string().optional().describe("Filter to sessions whose project directory contains this substring"),
+            since: z.string().optional().describe("ISO timestamp or relative shorthand like '7d' / '24h'"),
+            limit: z.number().int().positive().max(MAX_SEARCH_LIMIT).optional().describe(`Max hits (default ${DEFAULT_SEARCH_LIMIT})`),
+            all_matches: z
+                .boolean()
+                .optional()
+                .describe("Return every matching message instead of one best hit per session"),
+        },
+    }, async ({ query, project, since, limit, all_matches }) => {
+        const hits = search(db, query, {
+            project,
+            since,
+            allMatches: all_matches,
+            limit: limit ?? DEFAULT_SEARCH_LIMIT,
+        });
+        if (hits.length === 0) {
+            if (!hasAnyMessages(db)) {
+                return textResult(`No matches for "${query}" — the index is empty. Run \`rewound index\` on this machine first to index its session transcripts.`);
+            }
+            return textResult(`No matches for "${query}".`);
+        }
+        const blocks = hits.map((h) => [
+            `session: ${h.sessionId}${h.title ? ` (${h.title})` : ""}`,
+            `project: ${h.projectDir}  date: ${h.ts}  match_uuid: ${h.uuid}` +
+                (h.matchesInSession > 1 ? `  matches_in_session: ${h.matchesInSession}` : ""),
+            collapseSnippetWhitespace(centeredExcerpt(h.text, query, EXCERPT_CHARS)),
+        ].join("\n"));
+        const body = joinWithinBudget(blocks, "\n\n---\n\n", MAX_RESPONSE_BYTES - 200);
+        return textResult(`${body}\n\nUse get_session_excerpt(session_id, match_uuid) for more context around a hit.`);
+    });
+    server.registerTool("get_session_summary", {
+        description: "Summary of one past session: title, project, dates, message count, tools/models used, " +
+            "first user prompt and last assistant response (truncated).",
+        inputSchema: {
+            session_id: z.string().describe("Session id or a unique id prefix"),
+        },
+    }, async ({ session_id }) => {
+        const session = getSessionByIdOrPrefix(db, session_id);
+        if (!session)
+            return textResult(`No session found matching "${session_id}".`, true);
+        const messages = getMessagesForSession(db, session.id);
+        const firstUser = messages.find((m) => m.role === "user");
+        const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+        const toolsUsed = new Set();
+        for (const m of messages) {
+            for (const t of parseJsonStringArray(m.tools))
+                toolsUsed.add(t);
+        }
+        const lines = [
+            `session: ${session.id}`,
+            `title: ${truncate(session.title ?? "(untitled)", SUMMARY_TEXT_CHARS)}`,
+            `project: ${session.projectDir}  branch: ${session.gitBranch ?? "?"}`,
+            `started: ${session.startedAt ?? "?"}  ended: ${session.endedAt ?? "?"}`,
+            `messages: ${session.messageCount}`,
+            `models: ${truncate(session.models.join(", ") || "(none)", SUMMARY_TEXT_CHARS)}`,
+            `tools used: ${truncate(Array.from(toolsUsed).join(", ") || "(none)", SUMMARY_TEXT_CHARS)}`,
+            `first user prompt: ${truncate(firstUser?.text ?? "", SUMMARY_TEXT_CHARS)}`,
+            `last assistant response: ${truncate(lastAssistant?.text ?? "", SUMMARY_TEXT_CHARS)}`,
+        ];
+        return textResult(joinWithinBudget(lines, "\n", MAX_RESPONSE_BYTES));
+    });
+    server.registerTool("get_session_excerpt", {
+        description: "Readable excerpt of a session: the message matching match_uuid plus `context` messages on " +
+            "each side (or the start of the session if match_uuid is omitted).",
+        inputSchema: {
+            session_id: z.string().describe("Session id or a unique id prefix"),
+            match_uuid: z.string().optional().describe("uuid of the message to center the excerpt on (from search_history)"),
+            context: z
+                .number()
+                .int()
+                .min(0)
+                .max(MAX_EXCERPT_CONTEXT)
+                .optional()
+                .describe(`Messages of context on each side (default ${DEFAULT_EXCERPT_CONTEXT})`),
+        },
+    }, async ({ session_id, match_uuid, context }) => {
+        const session = getSessionByIdOrPrefix(db, session_id);
+        if (!session)
+            return textResult(`No session found matching "${session_id}".`, true);
+        const messages = getMessagesForSession(db, session.id);
+        const windowSize = context ?? DEFAULT_EXCERPT_CONTEXT;
+        let start = 0;
+        let end = Math.min(messages.length, windowSize * 2 + 1);
+        if (match_uuid) {
+            const idx = messages.findIndex((m) => m.uuid === match_uuid);
+            if (idx === -1) {
+                return textResult(`No message with uuid "${match_uuid}" in session "${session.id}".`, true);
+            }
+            start = Math.max(0, idx - windowSize);
+            end = Math.min(messages.length, idx + windowSize + 1);
+        }
+        const lines = messages.slice(start, end).map((m) => {
+            const tools = parseJsonStringArray(m.tools);
+            const toolSummary = tools.length ? ` [tools: ${tools.join(", ")}]` : "";
+            const sidechain = m.is_sidechain ? " (sidechain)" : "";
+            return `[${m.ts}] ${m.role}${sidechain}: ${truncate(m.text, EXCERPT_CHARS)}${toolSummary}`;
+        });
+        return textResult(joinWithinBudget(lines, "\n", MAX_RESPONSE_BYTES));
+    });
+    return server;
+}
+export async function startMcpServer(db) {
+    const server = createMcpServer(db);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/pricing.js

@@ -0,0 +1,21 @@
+// $/Mtok. Estimated — update here when Anthropic changes pricing.
+export const PRICING_TABLE = [
+    { match: "opus", input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+    { match: "sonnet", input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+    { match: "haiku", input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
+];
+export function findPricingRow(model) {
+    if (!model)
+        return undefined;
+    const lower = model.toLowerCase();
+    return PRICING_TABLE.find((row) => lower.includes(row.match));
+}
+export function estimateCostUsd(model, usage) {
+    const row = findPricingRow(model);
+    if (!row)
+        return 0;
+    return ((usage.input / 1_000_000) * row.input +
+        (usage.output / 1_000_000) * row.output +
+        (usage.cacheRead / 1_000_000) * row.cacheRead +
+        (usage.cacheWrite / 1_000_000) * row.cacheWrite);
+}

package/dist/search.js

@@ -0,0 +1,62 @@
+import { searchMessagesRaw } from "./db.js";
+// Snippets lifted from code/tool dumps carry embedded newlines, tabs and
+// indentation that wreck scannability in a result list. Collapse for display
+// only — stored text and raw snippet data are untouched.
+export function collapseSnippetWhitespace(snippet) {
+    return snippet.replace(/\s+/g, " ").trim();
+}
+const RELATIVE_SINCE_RE = /^(\d+)([hd])$/;
+export function resolveSince(since, now = new Date()) {
+    if (!since)
+        return undefined;
+    const m = RELATIVE_SINCE_RE.exec(since);
+    if (!m)
+        return since; // assume already an ISO timestamp
+    const amount = Number(m[1]);
+    const unitMs = m[2] === "h" ? 60 * 60 * 1000 : 24 * 60 * 60 * 1000;
+    return new Date(now.getTime() - amount * unitMs).toISOString();
+}
+// FTS5 treats bare user input as query syntax (":", "-", etc. are operators).
+// Quote each term so search input can never throw a MATCH syntax error;
+// --raw opts out for users who want real FTS5 query syntax.
+export function buildMatchExpression(query, raw) {
+    const trimmed = query.trim();
+    if (raw)
+        return trimmed;
+    const terms = trimmed.split(/\s+/).filter(Boolean);
+    return terms.map((t) => `"${t.replace(/"/g, '""')}"`).join(" ");
+}
+export function search(db, query, opts) {
+    const matchExpr = buildMatchExpression(query, Boolean(opts.raw));
+    const rawOpts = {
+        project: opts.project,
+        since: resolveSince(opts.since),
+        role: opts.role,
+        sidechains: opts.sidechains,
+        allMatches: opts.allMatches,
+        limit: opts.limit,
+        offset: opts.offset,
+    };
+    let rows;
+    try {
+        rows = searchMessagesRaw(db, matchExpr, rawOpts);
+    }
+    catch {
+        // Malformed FTS5 syntax (only reachable via --raw): fail soft with no hits.
+        return [];
+    }
+    return rows.map((r) => ({
+        sessionId: r.sessionId,
+        uuid: r.uuid,
+        role: r.role,
+        ts: r.ts,
+        projectDir: r.projectDir,
+        title: r.title,
+        snippet: r.snippet,
+        text: r.text,
+        model: r.model,
+        isSidechain: r.isSidechain,
+        estCostUsd: r.estCostUsd,
+        matchesInSession: r.matchesInSession,
+    }));
+}

package/dist/server.js

@@ -0,0 +1,176 @@
+import Fastify from "fastify";
+import { search } from "./search.js";
+import { listRecentProjects, listSessions, getSessionByIdOrPrefix, getMessagesForSession, getStats, getDailyMessageCounts, parseJsonStringArray, } from "./db.js";
+import { renderLayout } from "./web/layout.js";
+import { escapeHtml } from "./web/html.js";
+import { renderSearchPage } from "./web/pages/search.js";
+import { renderSessionPage } from "./web/pages/session.js";
+import { renderTimelinePage } from "./web/pages/timeline.js";
+import { fillDailySeries, renderStatsPage } from "./web/pages/stats.js";
+const PAGE_SIZE = 25;
+const STATS_DAYS = 30;
+const TIMELINE_SESSION_LIMIT = 500;
+// Cap the search page's project suggestions so page weight stays bounded
+// regardless of corpus size — the underlying filter still accepts any
+// substring typed in, this just limits the datalist hint list.
+const DEFAULT_SEARCH_PROJECT_SUGGESTIONS = 50;
+// Same reasoning for the timeline's "pick a project" list.
+const DEFAULT_TIMELINE_PROJECT_LIMIT = 100;
+// Cap messages rendered per session page — real corpus sessions can run to
+// 10k+ messages / several MB of HTML, which is unusable over a phone/Tailscale
+// connection. Defaults to the most recent page (where a resumed session's
+// context actually is); ?page= navigates to earlier parts of the transcript.
+const DEFAULT_SESSION_PAGE_SIZE = 150;
+function parseRole(v) {
+    return v === "user" || v === "assistant" ? v : undefined;
+}
+// Fastify parses a repeated query param (?q=a&q=b) as an array rather than
+// erroring, so every query field must be coerced through this before use.
+function firstQueryValue(v) {
+    if (Array.isArray(v))
+        return typeof v[0] === "string" ? v[0] : undefined;
+    return typeof v === "string" ? v : undefined;
+}
+// `message` is always escaped internally so callers can pass raw untrusted
+// text (e.g. a session id) straight in; `extraHtml` is an explicit raw-HTML
+// slot for callers that already built safe markup (e.g. a pre-escaped link).
+function renderErrorBody(code, message, extraHtml = "") {
+    return `<div class="error-page"><div class="error-code">${code}</div><p>${escapeHtml(message)}</p>${extraHtml}</div>`;
+}
+export function buildServer(opts) {
+    const { db } = opts;
+    const searchProjectSuggestions = opts.searchProjectSuggestions ?? DEFAULT_SEARCH_PROJECT_SUGGESTIONS;
+    const timelineProjectLimit = opts.timelineProjectLimit ?? DEFAULT_TIMELINE_PROJECT_LIMIT;
+    const sessionPageSize = opts.sessionPageSize ?? DEFAULT_SESSION_PAGE_SIZE;
+    const app = Fastify({ logger: false });
+    app.setNotFoundHandler((_req, reply) => {
+        reply
+            .code(404)
+            .type("text/html; charset=utf-8")
+            .send(renderLayout({
+            title: "Not found",
+            body: renderErrorBody(404, "Page not found.", '<p><a class="tap-target" href="/">Back to search</a></p>'),
+        }));
+    });
+    app.setErrorHandler((err, _req, reply) => {
+        reply
+            .code(500)
+            .type("text/html; charset=utf-8")
+            .send(renderLayout({
+            title: "Error",
+            body: renderErrorBody(500, "Something went wrong handling your request.", `<p class="muted">${escapeHtml(err.message)}</p>`),
+        }));
+    });
+    app.get("/", async (req, reply) => {
+        const query = req.query;
+        const q = (firstQueryValue(query.q) ?? "").trim();
+        const page = Math.max(1, parseInt(firstQueryValue(query.page) ?? "1", 10) || 1);
+        const project = firstQueryValue(query.project) || undefined;
+        const since = firstQueryValue(query.since) || undefined;
+        const role = parseRole(firstQueryValue(query.role));
+        const sidechains = firstQueryValue(query.sidechains) === "1";
+        const allMatches = firstQueryValue(query.all) === "1";
+        const searchOpts = {
+            project,
+            since,
+            role,
+            sidechains,
+            allMatches,
+            limit: PAGE_SIZE + 1,
+            offset: (page - 1) * PAGE_SIZE,
+        };
+        const hits = q ? search(db, q, searchOpts) : [];
+        const hasMore = hits.length > PAGE_SIZE;
+        const pageHits = hits.slice(0, PAGE_SIZE);
+        const projects = listRecentProjects(db, searchProjectSuggestions);
+        const body = renderSearchPage({
+            q,
+            project: project ?? "",
+            since: since ?? "",
+            role: role ?? "",
+            sidechains,
+            allMatches,
+            hits: pageHits,
+            projects,
+            page,
+            hasMore,
+        });
+        reply
+            .type("text/html; charset=utf-8")
+            .send(renderLayout({ title: "Search", activeNav: "search", body }));
+    });
+    app.get("/session/:id", async (req, reply) => {
+        const { id } = req.params;
+        const session = getSessionByIdOrPrefix(db, id);
+        if (!session) {
+            reply
+                .code(404)
+                .type("text/html; charset=utf-8")
+                .send(renderLayout({
+                title: "Not found",
+                body: renderErrorBody(404, `No session found matching "${id}".`, '<p><a class="tap-target" href="/">Back to search</a></p>'),
+            }));
+            return;
+        }
+        const totalPages = Math.max(1, Math.ceil(session.messageCount / sessionPageSize));
+        const query = req.query;
+        const requestedPage = parseInt(firstQueryValue(query.page) ?? "", 10);
+        const page = Number.isInteger(requestedPage) && requestedPage >= 1 && requestedPage <= totalPages
+            ? requestedPage
+            : totalPages;
+        const offset = (page - 1) * sessionPageSize;
+        const messages = getMessagesForSession(db, session.id, {
+            limit: sessionPageSize,
+            offset,
+        }).map((r) => ({
+            uuid: r.uuid,
+            role: r.role,
+            ts: r.ts,
+            text: r.text,
+            tools: parseJsonStringArray(r.tools),
+            model: r.model ?? undefined,
+            isSidechain: Boolean(r.is_sidechain),
+        }));
+        const body = renderSessionPage(session, messages, { page, totalPages });
+        reply
+            .type("text/html; charset=utf-8")
+            .send(renderLayout({ title: session.title ?? session.id, body }));
+    });
+    app.get("/timeline", async (req, reply) => {
+        const query = req.query;
+        const project = firstQueryValue(query.project) || undefined;
+        const projects = listRecentProjects(db, timelineProjectLimit);
+        const sessions = project ? listSessions(db, { project, limit: TIMELINE_SESSION_LIMIT }) : [];
+        const body = renderTimelinePage({
+            projects,
+            selectedProject: project,
+            sessions: sessions.map((s) => ({
+                id: s.id,
+                title: s.title,
+                startedAt: s.startedAt,
+                estCostUsd: s.estCostUsd,
+                messageCount: s.messageCount,
+            })),
+        });
+        reply
+            .type("text/html; charset=utf-8")
+            .send(renderLayout({ title: "Timeline", activeNav: "timeline", body }));
+    });
+    app.get("/stats", async (_req, reply) => {
+        const stats = getStats(db, 20);
+        const since = new Date(Date.now() - (STATS_DAYS - 1) * 24 * 60 * 60 * 1000).toISOString();
+        const daily = getDailyMessageCounts(db, since);
+        const dailyCounts = fillDailySeries(daily, STATS_DAYS, new Date());
+        const body = renderStatsPage({
+            totalSessions: stats.totalSessions,
+            totalMessages: stats.totalMessages,
+            totalCostUsd: stats.totalCostUsd,
+            byProject: stats.byProject,
+            dailyCounts,
+        });
+        reply
+            .type("text/html; charset=utf-8")
+            .send(renderLayout({ title: "Stats", activeNav: "stats", body }));
+    });
+    return app;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/web/html.js

@@ -0,0 +1,14 @@
+export function escapeHtml(input) {
+    return input
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+// FTS5 snippet() wraps matches in \x01...\x02 marker bytes (see search.ts).
+// Escape first (control bytes pass through untouched), then swap markers for
+// <mark> tags so injected match text can never break out of the tag.
+export function highlightSnippetHtml(snippet) {
+    return escapeHtml(snippet).replace(/\x01/g, "<mark>").replace(/\x02/g, "</mark>");
+}