reviewzy 0.3.0 → 0.4.0

package/src/dashboard/word-diff.ts

@@ -1,7 +1,9 @@
 /**
  * The word-level diff between the anchor text and the proposed text, computed server-side at
- * render time so the marks need no client js. Whitespace-token based: the split keeps whitespace
- * runs as their own tokens, so both streams re-join to their exact input, bytes included.
+ * render time so the marks need no client js. The walk returns one unified stream in reading
+ * order: kept tokens once, removed and added tokens in place between them. Whitespace-token
+ * based: the split keeps whitespace runs as their own tokens, so the tokens re-join to their
+ * exact inputs, bytes included.
  */
 
 /** One token of a diffed string, carrying its mark. Whitespace runs are tokens too, always `same` when both sides share them. */
@@ -10,13 +12,6 @@ export type WordDiffToken = {
   readonly kind: "same" | "removed" | "added";
 };
 
-export type WordDiff = {
-  /** The anchor text tokenized: tokens the proposal does not keep are `removed`, the rest `same`. */
-  readonly before: readonly WordDiffToken[];
-  /** The proposal tokenized: tokens the anchor did not have are `added`, the rest `same`. */
-  readonly after: readonly WordDiffToken[];
-};
-
 /** Splits on whitespace boundaries, keeping the runs: `"a b"` becomes `["a", " ", "b"]`. */
 function tokenize(text: string): string[] {
   return text.split(/(\s+)/).filter((token) => token !== "");
@@ -32,17 +27,17 @@ const MAX_LCS_CELLS = 1_000_000;
 /**
  * A longest-common-subsequence walk over the two token streams: a token both sides share is
  * `same`, one only the anchor has is `removed`, one only the proposal has is `added`. Identical
- * strings produce all-`same` streams, so nothing renders a mark.
+ * strings produce all-`same` tokens, so nothing renders a mark.
  */
-export function diffWords(before: string, after: string): WordDiff {
+export function diffWords(before: string, after: string): readonly WordDiffToken[] {
   const a = tokenize(before);
   const b = tokenize(after);
 
   if (a.length * b.length > MAX_LCS_CELLS) {
-    return {
-      before: a.map((text) => ({ text, kind: "removed" as const })),
-      after: b.map((text) => ({ text, kind: "added" as const })),
-    };
+    return [
+      ...a.map((text) => ({ text, kind: "removed" as const })),
+      ...b.map((text) => ({ text, kind: "added" as const })),
+    ];
   }
 
   // dp[i][j] is the LCS length of a[i:] against b[j:], filled bottom-up so the walk can pick the
@@ -53,37 +48,35 @@ export function diffWords(before: string, after: string): WordDiff {
     for (let j = b.length - 1; j >= 0; j--) {
       const below = dp[(i + 1) * stride + j]!;
       const right = dp[i * stride + j + 1]!;
-      dp[i * stride + j] = a[i] === b[j] ? below + 1 : Math.max(below, right);
+      dp[i * stride + j] = a[i] === b[j] ? dp[(i + 1) * stride + j + 1]! + 1 : Math.max(below, right);
     }
   }
 
-  const beforeTokens: WordDiffToken[] = [];
-  const afterTokens: WordDiffToken[] = [];
+  const tokens: WordDiffToken[] = [];
   let i = 0;
   let j = 0;
   while (i < a.length && j < b.length) {
     if (a[i] === b[j]) {
-      beforeTokens.push({ text: a[i]!, kind: "same" });
-      afterTokens.push({ text: b[j]!, kind: "same" });
+      tokens.push({ text: a[i]!, kind: "same" });
       i++;
       j++;
     } else if (dp[(i + 1) * stride + j]! >= dp[i * stride + j + 1]!) {
       // Skipping the anchor's token keeps at least as long a match: it is removed.
-      beforeTokens.push({ text: a[i]!, kind: "removed" });
+      tokens.push({ text: a[i]!, kind: "removed" });
       i++;
     } else {
-      afterTokens.push({ text: b[j]!, kind: "added" });
+      tokens.push({ text: b[j]!, kind: "added" });
       j++;
     }
   }
   while (i < a.length) {
-    beforeTokens.push({ text: a[i]!, kind: "removed" });
+    tokens.push({ text: a[i]!, kind: "removed" });
     i++;
   }
   while (j < b.length) {
-    afterTokens.push({ text: b[j]!, kind: "added" });
+    tokens.push({ text: b[j]!, kind: "added" });
     j++;
   }
 
-  return { before: beforeTokens, after: afterTokens };
+  return tokens;
 }

package/src/db/migrations.ts

@@ -55,7 +55,7 @@ export const MIGRATIONS: Migration[] = [
 
       -- entry_id keeps a plain NO ACTION foreign key: a sweep that archives an entry without
       -- first moving its revisions must fail loudly rather than orphan or destroy them
-      -- (cloudy, 2026-08-15; mcp-contract "three more tables").
+      -- (mcp-contract "three more tables").
       CREATE TABLE entry_revisions (
         id TEXT PRIMARY KEY NOT NULL,
         entry_id TEXT NOT NULL REFERENCES entries(id),
@@ -93,8 +93,7 @@ export const MIGRATIONS: Migration[] = [
       );
 
       -- Mirrors entry_revisions plus archived_at; a sweep moves an entry's revisions here in the
-      -- same transaction as the entry's own move, so the history has no expiry
-      -- (cloudy, 2026-08-15; docs/design.md "revisions").
+      -- same transaction as the entry's own move, so the history has no expiry.
       CREATE TABLE entry_revisions_archive (
         id TEXT PRIMARY KEY NOT NULL,
         entry_id TEXT NOT NULL REFERENCES entries_archive(id),
@@ -138,8 +137,8 @@ export const MIGRATIONS: Migration[] = [
     name: "mark-applied",
     sql: `
       -- mark_applied stores the hash of the text the agent applied; the contract's param table
-      -- listed applied_hash a day before the entry schema had a column to hold it (cloudy,
-      -- 2026-08-16), so the column lands now, with the doc edit in the same round.
+      -- listed applied_hash a day before the entry schema had a column to hold it, so the column
+      -- lands now, with the doc edit in the same round.
       ALTER TABLE entries ADD COLUMN applied_hash TEXT;
       -- entries_archive mirrors entries column-for-column: the retention sweep copies applied
       -- rows over whole, so it must not lose the new column.
@@ -151,7 +150,7 @@ export const MIGRATIONS: Migration[] = [
     name: "entry-title",
     sql: `
       -- An optional human-readable label the dashboard shows in place of the file basename, so a
-      -- row reads as what it changes rather than where it lives (cloudy, 2026-08-20). Nullable:
+      -- row reads as what it changes rather than where it lives. Nullable:
       -- an entry without one falls back to its anchor text at render. The archive mirrors entries
       -- column-for-column, so it gains the column too.
       ALTER TABLE entries ADD COLUMN title TEXT;

package/src/db/queries.ts

@@ -154,6 +154,20 @@ export function countEntries(store: Store): number {
   return row.n;
 }
 
+/**
+ * The store's counts per status, zero-filled for every status the schema's CHECK admits. The
+ * dashboard's four stat cards read one number each; the sidebar's badge reads `draft`.
+ */
+export function countEntriesByStatus(store: Store): Record<EntryStatus, number> {
+  const rows = store.db.query("SELECT status, COUNT(*) AS n FROM entries GROUP BY status").all() as {
+    status: EntryStatus;
+    n: number;
+  }[];
+  const counts: Record<EntryStatus, number> = { draft: 0, approved: 0, applied: 0, rejected: 0 };
+  for (const row of rows) counts[row.status] = row.n;
+  return counts;
+}
+
 /**
  * `INSERT ... ON CONFLICT DO NOTHING` followed by the read: two calls racing to auto-create the
  * same slug both succeed, and the second takes the first's id rather than dying on `UNIQUE(slug)`.
@@ -312,6 +326,29 @@ export function listEntries(store: Store, filter: ListEntriesFilter): ListEntrie
   return { rows, nextCursor };
 }
 
+/**
+ * Splits ids a read could not return into the two answers a caller acts on differently: never
+ * filed (a typo, a renamed entry) and archived (the retention sweep holds it). A live row another
+ * filter hid is in neither list — it exists, and only the filter excluded it, so it is not missing.
+ */
+export function resolveEntryIds(
+  store: Store,
+  ids: readonly string[],
+): { missing: string[]; archived: string[] } {
+  const live = store.db
+    .query(`SELECT id FROM entries WHERE id IN (${ids.map(() => "?").join(", ")})`)
+    .all(...ids) as { id: string }[];
+  const liveIds = new Set(live.map((row) => row.id));
+  const missing = ids.filter((id) => !liveIds.has(id));
+  if (missing.length === 0) return { missing, archived: [] };
+
+  const archived = store.db
+    .query(`SELECT id FROM entries_archive WHERE id IN (${missing.map(() => "?").join(", ")})`)
+    .all(...missing) as { id: string }[];
+  const archivedIds = new Set(archived.map((row) => row.id));
+  return { missing, archived: missing.filter((id) => archivedIds.has(id)) };
+}
+
 /**
  * The entries immediately before and after `id` in the ascending-id walk the list renders, for the
  * editor's full-height prev/next rails; null at either boundary. The `id` column is a primary key,

package/src/mcp/file-entries.ts

@@ -252,7 +252,7 @@ export function registerFileEntriesTool(server: McpServer, baseUrl: string, stor
     {
       title: "File entries for review",
       description:
-        "File the text you want changed as draft entries for a human to author, approve or reject on the dashboard. One entry is one edit: a multi-line block is ONE entry, not one entry per line. Re-filing a known anchor is safe: a draft updates in place; an approved, applied or rejected entry comes back untouched. The dashboard groups entries by project and batch, newest batches first.",
+        "File the text you want changed as draft entries for a human to author, approve or reject on the dashboard. One entry is one edit: a multi-line block is ONE entry, not one entry per line. Re-filing a known anchor is safe: a draft updates in place; an approved, applied or rejected entry comes back untouched. The dashboard groups entries by project.",
       inputSchema: z.object({
         project: z.string().min(1).describe("The project slug: 1-63 chars of lowercase letters, digits, and inner hyphens. An unknown slug auto-creates the project on first file."),
         entries: z.array(FileEntryArgs).min(1).describe("The entries to file. One edit per entry."),

package/src/mcp/list-entries.ts

@@ -1,6 +1,6 @@
 import type { McpServer } from "@modelcontextprotocol/server";
 import { z } from "zod";
-import { listEntries, listProjects, projectIdBySlug } from "../db/queries.ts";
+import { listEntries, listProjects, projectIdBySlug, resolveEntryIds } from "../db/queries.ts";
 import type { EntryRow } from "../db/queries.ts";
 import type { Store } from "../db/store.ts";
 
@@ -70,6 +70,8 @@ const Entry = z.object({
 const ListEntriesOutput = z.object({
   entries: z.array(Entry),
   next_cursor: z.string().optional(),
+  missing_ids: z.array(z.string()).optional(),
+  archived_ids: z.array(z.string()).optional(),
 });
 
 /** A refusal is an ordinary thrown Error: the SDK answers it as a tool result with `isError: true`, never as a json-rpc protocol error. */
@@ -88,7 +90,7 @@ export function registerListEntriesTool(server: McpServer, store: Store): void {
     {
       title: "List entries for review",
       description:
-        "List the review queue's entries, ordered by ascending entry id. Every filter is optional and combines with AND. Walk pages via next_cursor; the walk is exhausted when it stops coming back. Each row is a lean index: id, project slug, file, title, status, updated_at. Apply-back fields (anchor, hashes, human text, constraints) come back through fetch_approved, and rejected or applied entries expose no agent-readable text anywhere — the dashboard owns authoring.",
+        "List the review queue's entries, ordered by ascending entry id. Every filter is optional and combines with AND. Walk pages via next_cursor; the walk is exhausted when it stops coming back. Each row is a lean index: id, project slug, file, title, status, updated_at. Apply-back fields (anchor, hashes, human text, constraints) come back through fetch_approved, and rejected or applied entries expose no agent-readable text anywhere — the dashboard owns authoring. An ids call adds missing_ids for an id no live row holds and archived_ids for one the sweep archived.",
       inputSchema: ListEntriesArgs,
       outputSchema: ListEntriesOutput,
     },
@@ -119,9 +121,16 @@ export function registerListEntriesTool(server: McpServer, store: Store): void {
       // empty page must never smuggle one in. The slug map mirrors the dashboard's own
       // project_id → slug resolution (the store row carries the fk, never the slug).
       const slugByProjectId = new Map(listProjects(store).map((p) => [p.id, p.slug]));
+      // Only a caller that asked by exact id needs the ids it cannot see; a filtered walk reports
+      // neither field, so its absence stays the statement that nothing was asked by id.
+      const resolved = args.ids === undefined ? undefined : resolveEntryIds(store, args.ids);
       const output = {
         entries: rows.map((row) => toWireEntry(row, slugByProjectId)),
         ...(nextCursor === null ? {} : { next_cursor: nextCursor }),
+        ...(resolved === undefined ? {} : {
+          missing_ids: resolved.missing,
+          archived_ids: resolved.archived,
+        }),
       };
       return {
         content: [{ type: "text" as const, text: JSON.stringify(output) }],