repoview 0.4.1 → 0.5.1

package/src/cli.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { startServer } from "./server.js";
+import { handleReviewCommand } from "./review-cli.js";
 
 function printHelp() {
   // Keep this in sync with README.md
@@ -23,6 +24,13 @@ Options:
   --no-watch        Disable live reload
   -h, --help        Show this help
 
+Review subcommands:
+  repoview review new --title "Title"              Create a new review thread
+  repoview review post <id> --role agent --body "…" Post a message to a thread
+  repoview review post <id> --role agent --file f   Post from file
+  repoview review read <id>                         Read thread messages + comments
+  repoview review list                              List all threads
+
 Environment:
   REPO_ROOT, HOST, PORT
 `);
@@ -55,6 +63,16 @@ if (help) {
   process.exit(0);
 }
 
+// Handle "review" subcommand
+if (parsed.rest[0] === "review") {
+  const repoRootForReview =
+    repo ??
+    process.env.REPO_ROOT ??
+    process.cwd();
+  await handleReviewCommand(parsed.rest.slice(1), repoRootForReview);
+  process.exit(0);
+}
+
 if (port != null && !Number.isFinite(port)) {
   process.stderr.write("Invalid --port value\n");
   process.exit(2);

package/src/markdown.js

@@ -16,6 +16,145 @@ function escapeHtml(s) {
     .replaceAll("'", "'");
 }
 
+function stripQuotes(s) {
+  if (s.length >= 2) {
+    const first = s[0];
+    const last = s[s.length - 1];
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+      return s.slice(1, -1);
+    }
+  }
+  return s;
+}
+
+function parseFlowList(raw) {
+  return raw
+    .slice(1, -1)
+    .split(",")
+    .map((s) => stripQuotes(s.trim()))
+    .filter((s) => s.length > 0);
+}
+
+// Lightweight YAML frontmatter parser. Handles the common forms used in
+// markdown frontmatter: `key: value`, quoted strings, `key: [a, b, c]`,
+// and indented `- item` block lists. Returns null when the leading `---`
+// block doesn't look like YAML, so plain horizontal rules pass through.
+function extractFrontmatter(text) {
+  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!match) return { data: null, body: text };
+
+  const block = match[1];
+  const lines = block.split(/\r?\n/);
+  const data = {};
+  const order = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    const m = line.match(/^([A-Za-z_][\w-]*)\s*:\s*(.*)$/);
+    if (!m) {
+      // Anything other than a YAML key on a top-level line means this isn't
+      // really frontmatter — bail out and leave the body untouched.
+      return { data: null, body: text };
+    }
+    const key = m[1];
+    const raw = m[2].trim();
+    if (raw === "") {
+      const items = [];
+      let j = i + 1;
+      while (j < lines.length) {
+        const sub = lines[j].match(/^\s+-\s+(.*)$/);
+        if (!sub) break;
+        items.push(stripQuotes(sub[1].trim()));
+        j++;
+      }
+      if (items.length) {
+        data[key] = items;
+        order.push(key);
+        i = j - 1;
+      }
+      continue;
+    }
+    if (raw.startsWith("[") && raw.endsWith("]")) {
+      data[key] = parseFlowList(raw);
+    } else {
+      data[key] = stripQuotes(raw);
+    }
+    order.push(key);
+  }
+
+  if (order.length === 0) return { data: null, body: text };
+  // Replace the frontmatter region with blank lines so downstream source-line
+  // numbers stay aligned with the original markdown.
+  const consumed = match[0];
+  const newlineCount = (consumed.match(/\n/g) || []).length;
+  const body = "\n".repeat(newlineCount) + text.slice(consumed.length);
+  return { data, order, body };
+}
+
+const FRONTMATTER_KNOWN_KEYS = new Set([
+  "title",
+  "description",
+  "summary",
+  "subtitle",
+  "date",
+  "published",
+  "updated",
+  "author",
+  "authors",
+  "tags",
+  "categories",
+]);
+
+function renderFrontmatter(data, order) {
+  const title = data.title;
+  const description = data.description ?? data.summary ?? data.subtitle;
+  const date = data.date ?? data.published ?? data.updated;
+  const authorVal = data.author ?? data.authors;
+  const tagsVal = data.tags ?? data.categories;
+
+  const parts = ['<div class="md-frontmatter">'];
+  if (title) parts.push(`<h1 class="md-frontmatter-title">${escapeHtml(title)}</h1>`);
+  if (description)
+    parts.push(`<p class="md-frontmatter-description">${escapeHtml(description)}</p>`);
+
+  const meta = [];
+  if (date) meta.push(`<span class="md-frontmatter-date">${escapeHtml(date)}</span>`);
+  if (authorVal) {
+    const authors = Array.isArray(authorVal) ? authorVal : [authorVal];
+    if (authors.length) {
+      meta.push(
+        `<span class="md-frontmatter-author">${authors.map(escapeHtml).join(", ")}</span>`,
+      );
+    }
+  }
+  if (tagsVal) {
+    const tags = Array.isArray(tagsVal) ? tagsVal : [tagsVal];
+    if (tags.length) {
+      const items = tags
+        .map((t) => `<li class="md-frontmatter-tag">${escapeHtml(t)}</li>`)
+        .join("");
+      meta.push(`<ul class="md-frontmatter-tags">${items}</ul>`);
+    }
+  }
+  if (meta.length) parts.push(`<div class="md-frontmatter-meta">${meta.join("")}</div>`);
+
+  const extras = (order || Object.keys(data)).filter((k) => !FRONTMATTER_KNOWN_KEYS.has(k));
+  if (extras.length) {
+    const rows = extras
+      .map((k) => {
+        const v = data[k];
+        const display = Array.isArray(v) ? v.join(", ") : v;
+        return `<dt>${escapeHtml(k)}</dt><dd>${escapeHtml(display)}</dd>`;
+      })
+      .join("");
+    parts.push(`<dl class="md-frontmatter-extra">${rows}</dl>`);
+  }
+
+  parts.push("</div>");
+  return parts.join("");
+}
+
 // CommonMark only allows "1." to interrupt a paragraph, but GitHub allows any number.
 // This preprocessor adds blank lines before ordered lists starting with numbers other than 1.
 function normalizeOrderedLists(text) {
@@ -278,6 +417,18 @@ export function createMarkdownRenderer() {
     }
   });
 
+  // Source line mapping for inline comment anchoring (opt-in via env.emitLineMap)
+  md.core.ruler.push("source-line-map", (state) => {
+    if (!state.env.emitLineMap) return;
+    for (const token of state.tokens) {
+      if (token.nesting !== 1) continue; // only opening tokens
+      if (token.map && token.map.length === 2) {
+        token.attrSet("data-source-line-start", String(token.map[0] + 1));
+        token.attrSet("data-source-line-end", String(token.map[1]));
+      }
+    }
+  });
+
   function sanitize(html, env) {
     const baseDirPosix = env?.baseDirPosix || "";
     return sanitizeHtml(html, {
@@ -308,7 +459,7 @@ export function createMarkdownRenderer() {
         "input",
       ],
       allowedAttributes: {
-        "*": ["class", "id", "aria-label", "aria-hidden", "role", "align"],
+        "*": ["class", "id", "aria-label", "aria-hidden", "role", "align", "data-source-line-start", "data-source-line-end"],
         a: ["href", "name", "title", "target", "rel", "tabindex"],
         img: ["src", "alt", "title", "width", "height", "loading"],
         input: ["type", "checked", "disabled"],
@@ -347,8 +498,11 @@ export function createMarkdownRenderer() {
   return {
     render(markdown, env) {
       const e = env ?? {};
-      const html = md.render(markdown ?? "", e);
-      return sanitize(html, e);
+      const source = markdown ?? "";
+      const fm = extractFrontmatter(source);
+      const fmHtml = fm.data ? renderFrontmatter(fm.data, fm.order) : "";
+      const html = md.render(fm.body, e);
+      return sanitize(fmHtml + html, e);
     },
     renderCodeBlock(text, { languageHint } = {}) {
       const lang = languageHint && hljs.getLanguage(languageHint) ? languageHint : "";

package/src/review-cli.js

@@ -0,0 +1,245 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+function generateThreadId(title) {
+  const date = new Date().toISOString().slice(0, 10);
+  const slug = title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 50);
+  return `${date}-${slug}`;
+}
+
+function getNextMessageId(existingIds) {
+  let max = 0;
+  for (const id of existingIds) {
+    const n = parseInt(id, 10);
+    if (n > max) max = n;
+  }
+  return String(max + 1).padStart(3, "0");
+}
+
+export async function reviewNew({ title, reviewDir }) {
+  if (!title) {
+    process.stderr.write("Error: --title is required\n");
+    process.exit(1);
+  }
+
+  const id = generateThreadId(title);
+  const threadDir = path.join(reviewDir, id);
+  const messagesDir = path.join(threadDir, "messages");
+
+  await fs.mkdir(messagesDir, { recursive: true });
+
+  const now = new Date().toISOString();
+  const thread = {
+    id,
+    title,
+    createdAt: now,
+    lastActivityAt: now,
+    readUntil: null,
+  };
+
+  await fs.writeFile(path.join(threadDir, "thread.json"), JSON.stringify(thread, null, 2) + "\n");
+  await fs.writeFile(path.join(threadDir, "comments.json"), JSON.stringify({ comments: [] }, null, 2) + "\n");
+
+  process.stdout.write(id + "\n");
+}
+
+export async function reviewPost({ threadId, role, body, file, reviewDir }) {
+  if (!threadId) {
+    process.stderr.write("Error: thread-id is required\n");
+    process.exit(1);
+  }
+
+  const threadDir = path.join(reviewDir, threadId);
+  const messagesDir = path.join(threadDir, "messages");
+  const threadFile = path.join(threadDir, "thread.json");
+
+  try {
+    await fs.stat(threadFile);
+  } catch {
+    process.stderr.write(`Error: thread "${threadId}" not found\n`);
+    process.exit(1);
+  }
+
+  let messageBody = body || "";
+  if (file) {
+    messageBody = await fs.readFile(file, "utf8");
+  } else if (!body) {
+    // Read from stdin
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    messageBody = Buffer.concat(chunks).toString("utf8");
+  }
+
+  if (!messageBody.trim()) {
+    process.stderr.write("Error: message body is empty\n");
+    process.exit(1);
+  }
+
+  // Find next message ID
+  let entries = [];
+  try {
+    entries = await fs.readdir(messagesDir);
+  } catch {
+    await fs.mkdir(messagesDir, { recursive: true });
+  }
+  const existingIds = entries.filter((e) => e.endsWith(".json")).map((e) => e.replace(".json", ""));
+  const nextId = getNextMessageId(existingIds);
+
+  const now = new Date().toISOString();
+  const messageRole = role || "agent";
+  const format = messageRole === "agent" ? "markdown" : "text";
+
+  const message = {
+    id: nextId,
+    role: messageRole,
+    format,
+    body: messageBody,
+    createdAt: now,
+  };
+
+  await fs.writeFile(path.join(messagesDir, `${nextId}.json`), JSON.stringify(message, null, 2) + "\n");
+
+  // Update lastActivityAt in thread.json
+  const thread = JSON.parse(await fs.readFile(threadFile, "utf8"));
+  thread.lastActivityAt = now;
+  await fs.writeFile(threadFile, JSON.stringify(thread, null, 2) + "\n");
+
+  process.stdout.write(nextId + "\n");
+}
+
+export async function reviewRead({ threadId, reviewDir }) {
+  if (!threadId) {
+    process.stderr.write("Error: thread-id is required\n");
+    process.exit(1);
+  }
+
+  const threadDir = path.join(reviewDir, threadId);
+  const threadFile = path.join(threadDir, "thread.json");
+
+  try {
+    await fs.stat(threadFile);
+  } catch {
+    process.stderr.write(`Error: thread "${threadId}" not found\n`);
+    process.exit(1);
+  }
+
+  const thread = JSON.parse(await fs.readFile(threadFile, "utf8"));
+
+  const messagesDir = path.join(threadDir, "messages");
+  let messageFiles = [];
+  try {
+    messageFiles = (await fs.readdir(messagesDir)).filter((f) => f.endsWith(".json")).sort();
+  } catch {
+    // no messages yet
+  }
+
+  const messages = [];
+  for (const f of messageFiles) {
+    const msg = JSON.parse(await fs.readFile(path.join(messagesDir, f), "utf8"));
+    messages.push(msg);
+  }
+
+  let comments = { comments: [] };
+  try {
+    comments = JSON.parse(await fs.readFile(path.join(threadDir, "comments.json"), "utf8"));
+  } catch {
+    // no comments file
+  }
+
+  const result = { thread, messages, comments: comments.comments };
+  process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+}
+
+export async function reviewList({ reviewDir }) {
+  let entries = [];
+  try {
+    entries = await fs.readdir(reviewDir, { withFileTypes: true });
+  } catch {
+    process.stdout.write("[]\n");
+    return;
+  }
+
+  const threads = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const threadFile = path.join(reviewDir, entry.name, "thread.json");
+    try {
+      const thread = JSON.parse(await fs.readFile(threadFile, "utf8"));
+      // Count messages
+      let messageCount = 0;
+      try {
+        const msgs = await fs.readdir(path.join(reviewDir, entry.name, "messages"));
+        messageCount = msgs.filter((f) => f.endsWith(".json")).length;
+      } catch {
+        // no messages
+      }
+      threads.push({ ...thread, messageCount });
+    } catch {
+      // skip dirs without thread.json
+    }
+  }
+
+  // Sort by lastActivityAt, newest first
+  threads.sort((a, b) => new Date(b.lastActivityAt) - new Date(a.lastActivityAt));
+
+  process.stdout.write(JSON.stringify(threads, null, 2) + "\n");
+}
+
+export async function handleReviewCommand(argv, repoRoot) {
+  const subcommand = argv[0];
+  const args = argv.slice(1);
+
+  // Parse --review-dir flag
+  let reviewDir = path.join(repoRoot, ".repoview", "reviews");
+  const rest = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--review-dir") {
+      reviewDir = args[++i];
+    } else {
+      rest.push(args[i]);
+    }
+  }
+
+  // Parse subcommand-specific flags
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < rest.length; i++) {
+    const v = rest[i];
+    if (v === "--title") flags.title = rest[++i];
+    else if (v === "--role") flags.role = rest[++i];
+    else if (v === "--body") flags.body = rest[++i];
+    else if (v === "--file") flags.file = rest[++i];
+    else positional.push(v);
+  }
+
+  switch (subcommand) {
+    case "new":
+      await reviewNew({ title: flags.title, reviewDir });
+      break;
+    case "post":
+      await reviewPost({
+        threadId: positional[0],
+        role: flags.role,
+        body: flags.body,
+        file: flags.file,
+        reviewDir,
+      });
+      break;
+    case "read":
+      await reviewRead({ threadId: positional[0], reviewDir });
+      break;
+    case "list":
+      await reviewList({ reviewDir });
+      break;
+    default:
+      process.stderr.write(`Unknown review subcommand: ${subcommand}\n`);
+      process.stderr.write("Usage: repoview review <new|post|read|list> [options]\n");
+      process.exit(1);
+  }
+}