@levistudio/redline 0.1.0

package/src/resolve.ts

@@ -0,0 +1,290 @@
+import { appendFile, copyFile, mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { loadSidecar, saveSidecar } from "./sidecar";
+import type { Round } from "./sidecar";
+import { pickRevisionModel } from "./pickModel";
+import { newEnvelope } from "./promptEnvelope";
+import { contextBlock } from "./contextBlock";
+
+const serverBase = () => `http://localhost:${process.env.REDLINE_PORT ?? "3000"}`;
+const csrfHeader = (): Record<string, string> => ({ "X-Redline-Token": process.env.REDLINE_TOKEN ?? "" });
+
+export async function resolve(filePath: string, options: { model?: string } = {}) {
+  const model = options.model ?? null;
+  const sidecar = await loadSidecar(filePath);
+
+  // Find the most recently accepted round
+  const resolvedRounds = sidecar.rounds.filter((r) => r.resolved_at != null);
+  if (resolvedRounds.length === 0) {
+    throw new Error("No accepted round found — human must click 'Accept & revise' first");
+  }
+  const round: Round = resolvedRounds[resolvedRounds.length - 1];
+  const settled = round.comments.filter((c) => c.resolved);
+  const chosenModel = model ?? pickRevisionModel(settled);
+
+  const docText = await readFile(filePath, "utf-8");
+
+  // Save history snapshot before any changes
+  const historyDir = path.join(path.dirname(filePath), ".review", "history");
+  await mkdir(historyDir, { recursive: true });
+  const snapTs = new Date().toISOString();
+  const snapFile = path.join(historyDir, `${path.basename(filePath)}.${snapTs}.md`);
+  await copyFile(filePath, snapFile);
+  console.log(`Saved snapshot → .review/history/${path.basename(snapFile)}\n`);
+
+  if (settled.length === 0) {
+    console.log("No settled comments — no revision needed.");
+    await openNextRound(sidecar, filePath);
+    try { await fetch(`${serverBase()}/api/reload`, { method: "POST", headers: csrfHeader() }); } catch { /* non-fatal */ }
+    return;
+  }
+
+  // Build prompt — wrap user-controlled strings (quote, discussion text, the
+  // document body, prior-round agent replies that may echo user content) in a
+  // per-prompt envelope so adversarial comment content can't masquerade as
+  // system instructions or another section.
+  const env = newEnvelope();
+  const commentsBlock = settled
+    .map((c, i) => {
+      const discussion = c.thread
+        .map((e) => `    ${e.role === "agent" ? "Agent" : "Reviewer"}: ${e.message}`)
+        .join("\n");
+      return `${i + 1}. Quote:\n${env.wrap(`comment-${i}-quote`, c.quote)}\n   Discussion:\n${env.wrap(`comment-${i}-discussion`, discussion)}`;
+    })
+    .join("\n\n");
+
+  // Summarise what was agreed in earlier rounds so the model doesn't undo them
+  const priorRounds = resolvedRounds.slice(0, -1);
+  let priorChangesBlock = "";
+  if (priorRounds.length > 0) {
+    const lines = priorRounds.flatMap((r) =>
+      r.comments
+        .filter((c) => c.resolved)
+        .map((c) => {
+          const lastAgent = [...c.thread].reverse().find((e) => e.role === "agent");
+          return `- Round ${r.round}: ${env.wrap(`prior-${r.round}-quote`, c.quote)} → ${env.wrap(`prior-${r.round}-reply`, lastAgent?.message ?? "(resolved)")}`;
+        })
+    );
+    if (lines.length > 0) {
+      priorChangesBlock = `\n\n<previously-agreed-changes>\n${lines.join("\n")}\n</previously-agreed-changes>`;
+    }
+  }
+
+  const systemPrompt =
+    "You are revising a Markdown document based on settled reviewer comments.\n" +
+    "For each comment, edit the relevant passage in the document to reflect what was agreed.\n" +
+    "Preserve all sections that have no comments exactly as they are.\n" +
+    "Return ONLY the revised contents of <document> — the full Markdown document, nothing else.\n" +
+    "Do NOT include the <document> tags themselves in your output.\n" +
+    "Do NOT echo, summarize, or append any of the <comments-to-apply> or <previously-agreed-changes> content.\n" +
+    "Do NOT add commentary, preamble, or meta-sections like 'Settled comments' or 'Changelog'.\n" +
+    "The output should look like a clean revision of the original document — as if a human editor made the changes silently.\n" +
+    "\n" +
+    env.systemPromptHint();
+
+  // Prepend the reviewer's stated focus when --context was set; the helper
+  // returns empty otherwise. Goes before the comments so the model reads the
+  // user's lens first and weights the revision accordingly.
+  const userMessage =
+    contextBlock(sidecar.context, env) +
+    `<comments-to-apply>\n${commentsBlock}\n</comments-to-apply>${priorChangesBlock}\n\n<document>\n${env.wrap("document", docText)}\n</document>`;
+
+  // Call the claude CLI (inherits auth from the user's Claude Code session — no API key needed)
+  console.log(`Revising with ${chosenModel}...\n`);
+  console.log("─".repeat(60));
+  const revisionStartedAt = Date.now();
+
+  const cliBin = process.env.CLAUDE_CODE_EXECPATH ?? "claude";
+  const proc = Bun.spawn(
+    [cliBin, "-p", "--system-prompt", systemPrompt, "--model", chosenModel,
+     "--output-format", "stream-json", "--include-partial-messages", "--verbose"],
+    {
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    }
+  );
+
+  proc.stdin.write(userMessage);
+  proc.stdin.end();
+
+  // Drain stderr concurrently so we can include it in any error report
+  let stderrText = "";
+  (async () => {
+    const r = proc.stderr.getReader();
+    const dec = new TextDecoder();
+    while (true) {
+      const { done, value } = await r.read();
+      if (done) break;
+      const chunk = dec.decode(value);
+      stderrText += chunk;
+      process.stderr.write(chunk);
+    }
+  })();
+
+  let revised = "";
+  let buffer = "";
+  const reader = proc.stdout.getReader();
+  const broadcastChunk = (text: string, kind: "thinking" | "text") => {
+    fetch(`${serverBase()}/api/revision-chunk`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...csrfHeader() },
+      body: JSON.stringify({ text, kind }),
+    }).catch(() => {});
+  };
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += new TextDecoder().decode(value);
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === "stream_event" && obj.event?.type === "content_block_delta") {
+          const delta = obj.event.delta;
+          if (delta?.type === "text_delta" && delta.text) {
+            revised += delta.text;
+            process.stdout.write(delta.text);
+            broadcastChunk(delta.text, "text");
+          } else if (delta?.type === "thinking_delta" && delta.thinking) {
+            broadcastChunk(delta.thinking, "thinking");
+          }
+        }
+      } catch { /* malformed JSON line, skip */ }
+    }
+  }
+
+  const exitCode = await proc.exited;
+  const revisionDurationMs = Date.now() - revisionStartedAt;
+  console.log("\n" + "─".repeat(60));
+  console.log(`Model: ${chosenModel}  ·  Duration: ${(revisionDurationMs / 1000).toFixed(1)}s  ·  Exit: ${exitCode}`);
+  console.log("─".repeat(60) + "\n");
+
+  const fail = async (reason: string) => {
+    await logRevisionFailure(filePath, {
+      reason,
+      model: chosenModel,
+      exitCode,
+      stderr: stderrText.trim(),
+      stdoutSample: revised.slice(0, 2000),
+      stdoutLength: revised.length,
+    });
+    throw new Error(reason);
+  };
+
+  if (exitCode !== 0) {
+    await fail(`claude CLI exited with code ${exitCode}${stderrText.trim() ? ` — ${stderrText.trim().split("\n").slice(-3).join(" | ")}` : ""}`);
+  }
+
+  // Validate output. Strip a wrapping code fence if present, a preamble before the
+  // first heading, any <document> wrapper tags, and any meta-sections the model
+  // sometimes appends (Settled comments, Previously agreed changes, Changelog).
+  let trimmed = revised.trim()
+    .replace(/^```(?:markdown)?\n([\s\S]*)\n```$/, "$1")
+    .replace(/^<document>\s*/i, "")
+    .replace(/\s*<\/document>\s*$/i, "")
+    .trim();
+  // Strip trailing meta-sections at any heading level (## or ###).
+  const metaHeading = trimmed.match(/\n#{2,3} (Settled comments|Previously agreed changes|Changelog|Revision notes)\b/i);
+  if (metaHeading) {
+    console.log(`Stripping trailing meta-section: ${metaHeading[1]}`);
+    trimmed = trimmed.slice(0, metaHeading.index).trimEnd();
+    // Strip a trailing horizontal rule that often precedes the meta-section.
+    trimmed = trimmed.replace(/\n+---\s*$/, "").trimEnd();
+  }
+  if (!trimmed) {
+    await fail("Agent returned empty output (no text deltas streamed)");
+  }
+  if (!trimmed.startsWith("#")) {
+    const firstHeadingIdx = trimmed.search(/^# /m);
+    if (firstHeadingIdx > 0) {
+      console.log("Stripping preamble before first heading.");
+      trimmed = trimmed.slice(firstHeadingIdx).trim();
+    } else {
+      await fail("Output contains no Markdown heading — model returned non-document content");
+    }
+  }
+
+  // If the model made no changes, skip the write and signal the browser
+  if (trimmed === docText.trim()) {
+    console.log("No changes — output identical to input. Skipping file write.");
+    await openNextRound(sidecar, filePath);
+    try { await fetch(`${serverBase()}/api/revision-no-changes`, { method: "POST", headers: csrfHeader() }); } catch { /* non-fatal */ }
+    return;
+  }
+
+  // Write revised document
+  await writeFile(filePath, trimmed, "utf-8");
+
+  // Print change summary
+  printChangeSummary(docText, trimmed, filePath);
+
+  // Open next round
+  await openNextRound(sidecar, filePath);
+
+  // Notify browser to reload
+  try {
+    await fetch(`${serverBase()}/api/reload`, { method: "POST", headers: csrfHeader() });
+  } catch { /* server may not be running — non-fatal */ }
+}
+
+async function logRevisionFailure(
+  filePath: string,
+  details: { reason: string; model: string; exitCode: number; stderr: string; stdoutSample: string; stdoutLength: number }
+) {
+  const logDir = path.join(path.dirname(filePath), ".review");
+  await mkdir(logDir, { recursive: true });
+  const logPath = path.join(logDir, "errors.log");
+  const entry =
+    `\n=== ${new Date().toISOString()} — ${path.basename(filePath)} ===\n` +
+    `reason:       ${details.reason}\n` +
+    `model:        ${details.model}\n` +
+    `exitCode:     ${details.exitCode}\n` +
+    `stdoutLength: ${details.stdoutLength}\n` +
+    (details.stderr ? `stderr:\n${details.stderr}\n` : "") +
+    (details.stdoutSample ? `stdoutSample (first 2000 chars):\n${details.stdoutSample}\n` : "") +
+    `===\n`;
+  try {
+    await appendFile(logPath, entry, "utf-8");
+    console.error(`Logged failure → .review/errors.log`);
+  } catch (e) {
+    console.error("Failed to write error log:", e);
+  }
+}
+
+function printChangeSummary(oldText: string, newText: string, filePath: string) {
+  const heading = (text: string) => text.match(/^#{1,3} .+$/gm) ?? [];
+  const oldH = heading(oldText);
+  const newH = heading(newText);
+
+  const added = newH.filter((h) => !oldH.includes(h));
+  const removed = oldH.filter((h) => !newH.includes(h));
+
+  console.log(`✓ Revised: ${path.basename(filePath)}`);
+  removed.forEach((h) => console.log(`  − Removed: "${h}"`));
+  added.forEach((h) => console.log(`  + Added:   "${h}"`));
+  if (added.length === 0 && removed.length === 0) {
+    console.log("  ~ Sections unchanged, content updated in place");
+  }
+}
+
+async function openNextRound(sidecar: ReturnType<typeof loadSidecar> extends Promise<infer T> ? T : never, filePath: string) {
+  const hasOpenRound = sidecar.rounds.some((r) => r.resolved_at === null);
+  if (!hasOpenRound) {
+    const nextNum = sidecar.rounds.length + 1;
+    sidecar.rounds.push({
+      round: nextNum,
+      started_at: new Date().toISOString(),
+      submitted_at: null,
+      agent_replied_at: null,
+      resolved_at: null,
+      comments: [],
+    });
+    await saveSidecar(filePath, sidecar);
+    console.log(`\nOpened round ${nextNum} — ready for next review.`);
+  } else {
+    await saveSidecar(filePath, sidecar);
+  }
+}

package/src/server-page.ts

@@ -0,0 +1,119 @@
+import type { Comment } from "./sidecar";
+
+function escapeHtml(s: string): string {
+  return s
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function pageTemplate(
+  title: string,
+  content: string,
+  comments: Comment[],
+  roundResolved: boolean,
+  agentRepliedAt: string | null,
+  roundNumber: number,
+  totalRounds: number,
+  context?: string,
+  readOnly = false,
+  csrfToken = "",
+  noAgent = false
+): string {
+  const commentsJson = JSON.stringify(comments);
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)} — Redline</title>
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.10.0/styles/github.min.css">
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.10.0/highlight.min.js"></script>
+  <link rel="stylesheet" href="/styles.css">
+</head>
+<body>
+  <div class="layout">
+    <div class="reader-col">
+      <div class="doc-header">
+        <span class="doc-title">
+          ${escapeHtml(title)}
+          <span style="position:relative">
+            <span class="round-badge${totalRounds > 1 ? ' repeat' : ''}${totalRounds > 1 ? ' clickable' : ''}" id="round-badge">Round ${roundNumber} of ${totalRounds}</span>
+            ${totalRounds > 1 ? `<div class="round-picker" id="round-picker" style="display:none">${
+              Array.from({length: totalRounds}, (_, i) => i + 1).map(n => {
+                const isCurrent = n === roundNumber;
+                const href = n === totalRounds ? '/' : `/round/${n}`;
+                const label = n === totalRounds ? 'Round ' + n + ' — current' : 'Round ' + n;
+                return `<a class="round-picker-item${isCurrent ? ' current' : ''}" href="${href}">${label}</a>`;
+              }).join('')
+            }</div>` : ''}
+          </span>
+        </span>
+        <div class="header-actions">
+          <span id="agent-status" class="agent-status" hidden></span>
+          ${noAgent ? `<span class="manual-mode-pill" title="Started with --no-agent. No Claude replies, no revision pass.">Manual mode</span>` : ''}
+          ${readOnly
+            ? `<span style="font-size:13px;color:var(--text-muted);font-style:italic">Read-only — <a href="/" style="color:var(--accent)">back to current</a></span>`
+            : `<button class="btn-accept" id="btn-accept" disabled>Revise document</button>
+               ${totalRounds > 1 ? `<button class="btn-diff-compare" id="btn-compare">Compare with previous</button>` : ''}`
+          }
+        </div>
+      </div>
+      ${context ? `<div class="context-banner" id="context-banner">
+        <span class="context-label">Context</span>
+        <span class="context-text">${escapeHtml(context)}</span>
+        <button class="context-dismiss" onclick="dismissContextBanner()" aria-label="Dismiss">✕</button>
+      </div>` : ''}
+      ${!readOnly ? `<div class="first-run-banner" id="first-run-banner" hidden>
+        <span class="first-run-icon" aria-hidden="true">⚠</span>
+        <span class="first-run-text">Redline sends document and comment text to your local Claude Code agent. Use trusted docs.</span>
+        <button class="first-run-dismiss" id="first-run-dismiss" aria-label="Dismiss">Got it</button>
+      </div>` : ''}
+      <article class="prose" id="prose">
+        ${content}
+      </article>
+    </div>
+
+    <div class="sidebar-col">
+      <div id="sidebar-status-banner"></div>
+      <div id="comment-nav" style="display:none">
+        <span class="nav-count" id="nav-count"></span>
+        <button id="nav-prev">↑ Prev</button>
+        <button id="nav-next">Next ↓</button>
+      </div>
+    </div>
+  </div>
+
+
+  <div id="done-banner"></div>
+  <div id="diff-overlay">
+    <div id="diff-panel">
+      <div id="diff-panel-header">
+        <h2>Review changes</h2>
+        <button class="btn-diff-feedback" id="diff-btn-feedback">Give more feedback</button>
+        <button class="btn-diff-accept" id="diff-btn-accept">Looks good — close session</button>
+        <button class="btn-diff-close" id="diff-btn-close" aria-label="Close">✕</button>
+      </div>
+      <div id="diff-panel-body"></div>
+    </div>
+  </div>
+  <div id="error-banner" style="display:none;position:fixed;bottom:24px;left:50%;transform:translateX(-50%);background:#b71c1c;color:white;padding:12px 24px;border-radius:6px;font-size:14px;font-weight:500;box-shadow:0 1px 4px rgba(0,0,0,0.08);z-index:999;white-space:nowrap;"></div>
+
+  <script>
+    window.__REDLINE__ = {
+      comments: ${commentsJson},
+      roundResolved: ${roundResolved},
+      totalRounds: ${totalRounds},
+      contextTitle: ${JSON.stringify(title)},
+      csrfToken: ${JSON.stringify(csrfToken)},
+      noAgent: ${JSON.stringify(noAgent)},
+    };
+  </script>
+  <script src="/client.js" defer></script>
+</body>
+</html>`;
+}
+
+export { escapeHtml, pageTemplate };