poly-weaver 0.9.4 → 0.10.0

package/dist/user/host-curate-prompt.js

@@ -1,9 +1,10 @@
-import { applyBlockCursor, bold, cyan, dim, reset, visibleLength, } from "../ansi.js";
+import { bold, cyan, dim, reset, visibleLength, } from "../ansi.js";
 import { AgentInterruptedError } from "../agents/runner.js";
 import { renderMarkdown } from "../markdown.js";
 import { EmacsInputParser } from "./prompt.js";
-import { applySingleLineTextBufferEvent, isTextBufferEvent, } from "../text-editing/emacs-input.js";
-import { clipToWidth, tagFor, wrapToWidth, } from "./curate-prompt.js";
+import { applyTextBufferEvent, isTextBufferEvent, } from "../text-editing/emacs-input.js";
+import { cursorToVisual, renderWrappedLine, softWrapLine } from "../text-editing/soft-wrap.js";
+import { clipToWidth, tagFor, userAddedTag, wrapToWidth, } from "./curate-prompt.js";
 import { buildPlanPane } from "./plan-pane.js";
 import { buildSplitSurface, computeSplitMetrics } from "./split-surface.js";
 const DECISION_CYCLE = ["keep", "drop", "revise"];
@@ -22,16 +23,15 @@ const CITATION_MARKER = "\x1b[1;95m▶\x1b[0m";
  *     Up/Down cursor movement (the issues pane auto-scrolls to keep the
  *     active issue visible).
  *
- * Issues panel: title + summary + per-issue rows. Each issue's full
- * description is wrapped inline; when the cursor row is in revise mode and
- * the editor is open, an inline buffer line renders directly under the
- * issue.
+ * Issues panel: title + summary + reviewer issue rows, user-added rows, and
+ * a trailing add-feedback row. Descriptions are wrapped inline; open editors
+ * render as inline multi-line buffers.
  *
  *   - k/d/r toggles the cursor row's decision.
  *   - Tab cycles keep → drop → revise → keep.
- *   - Enter on a revise row begins or finishes the inline edit; Esc cancels.
+ *   - Enter on editable rows opens an inline editor; Esc cancels.
  *   - PageUp/PageDown/Home/End/wheel scrolls the plan.
- *   - Up/Down moves the cursor among issues.
+ *   - Up/Down moves the cursor among all navigable rows.
  *   - Ctrl+D submits; Ctrl+C quits poly-weaver (exit code 130). Inside the
  *     inline revise editor (`state.editing`), Ctrl+C cancels the edit only.
  *   - Ctrl+] is consumed by the host's `InputRouter` for dump capture.
@@ -53,6 +53,7 @@ export class HostBackedCuratePrompt {
             cursor: 0,
             decisions: issues.map(() => "keep"),
             comments: issues.map(() => undefined),
+            userAdded: [],
             editing: undefined,
             planScrollTop: 0,
             nextCycle: issues.map(() => 0),
@@ -76,7 +77,7 @@ export class HostBackedCuratePrompt {
                         state.decisions[i] = "keep";
                     }
                 }
-                return {
+                const result = {
                     decisions: state.decisions.map((dec, i) => {
                         const rec = { index: i, decision: dec };
                         if (dec === "revise" && state.comments[i]) {
@@ -85,6 +86,60 @@ export class HostBackedCuratePrompt {
                         return rec;
                     }),
                 };
+                if (state.userAdded.length > 0) {
+                    result.userAdded = [...state.userAdded];
+                }
+                return result;
+            };
+            const cancelEdit = () => {
+                const editing = state.editing;
+                if (!editing)
+                    return;
+                state.editing = undefined;
+                if (editing.target.kind === "reviewer-revise" &&
+                    !state.comments[editing.target.index]) {
+                    state.decisions[editing.target.index] = "keep";
+                }
+                clampCursor(issues.length, state);
+            };
+            const submitEdit = () => {
+                const editing = state.editing;
+                if (!editing)
+                    return;
+                const text = editing.buffer.lines.join("\n").trim();
+                state.editing = undefined;
+                if (editing.target.kind === "reviewer-revise") {
+                    const i = editing.target.index;
+                    state.comments[i] = text.length > 0 ? text : undefined;
+                    if (!state.comments[i])
+                        state.decisions[i] = "keep";
+                    return;
+                }
+                if (editing.target.kind === "user-edit") {
+                    const i = editing.target.index;
+                    if (text.length > 0) {
+                        state.userAdded[i] = text;
+                    }
+                    else {
+                        state.userAdded.splice(i, 1);
+                        clampCursor(issues.length, state);
+                    }
+                    return;
+                }
+                if (text.length > 0) {
+                    state.userAdded.push(text);
+                    state.cursor = issues.length + state.userAdded.length - 1;
+                }
+                clampCursor(issues.length, state);
+            };
+            const openReviewerEditor = (index, text = "") => {
+                state.editing = {
+                    target: { kind: "reviewer-revise", index },
+                    buffer: bufferFromText(text),
+                };
+            };
+            const openUserAddEditor = () => {
+                state.editing = { target: { kind: "user-add" }, buffer: emptyBuffer() };
             };
             const processEvents = (events) => {
                 let dirty = false;
@@ -93,25 +148,23 @@ export class HostBackedCuratePrompt {
                     if (finished)
                         break;
                     if (state.editing) {
-                        const i = state.editing.index;
                         if (event.type === "ctrl-c" || event.type === "escape") {
-                            state.editing = undefined;
-                            if (!state.comments[i])
-                                state.decisions[i] = "keep";
+                            cancelEdit();
                             dirty = true;
                             continue;
                         }
                         if (event.type === "ctrl-d" || event.type === "enter") {
-                            const text = state.editing.buffer.trim();
-                            state.comments[i] = text.length > 0 ? text : undefined;
-                            state.editing = undefined;
-                            if (!state.comments[i])
-                                state.decisions[i] = "keep";
+                            submitEdit();
+                            dirty = true;
+                            continue;
+                        }
+                        if (event.type === "ctrl-j") {
+                            dirty = applyCurateTextBufferEvent(state.editing, { type: "newline" }) || dirty;
                             dirty = true;
                             continue;
                         }
                         if (isTextBufferEvent(event)) {
-                            dirty = applySingleLineTextBufferEvent(state.editing, event) || dirty;
+                            dirty = applyCurateTextBufferEvent(state.editing, event) || dirty;
                             continue;
                         }
                         continue;
@@ -127,14 +180,17 @@ export class HostBackedCuratePrompt {
                         continue;
                     }
                     if (event.type === "arrow") {
+                        const total = navigableCount(issues.length, state);
                         if (event.direction === "up") {
-                            state.cursor = (state.cursor - 1 + issues.length) % issues.length;
-                            state.nextCycle[state.cursor] = 0;
+                            state.cursor = (state.cursor - 1 + total) % total;
+                            if (state.cursor < issues.length)
+                                state.nextCycle[state.cursor] = 0;
                             dirty = true;
                         }
                         else if (event.direction === "down") {
-                            state.cursor = (state.cursor + 1) % issues.length;
-                            state.nextCycle[state.cursor] = 0;
+                            state.cursor = (state.cursor + 1) % total;
+                            if (state.cursor < issues.length)
+                                state.nextCycle[state.cursor] = 0;
                             dirty = true;
                         }
                         continue;
@@ -171,28 +227,47 @@ export class HostBackedCuratePrompt {
                         continue;
                     }
                     if (event.type === "enter") {
-                        if (state.decisions[state.cursor] === "revise") {
+                        if (state.cursor < issues.length) {
+                            if (state.decisions[state.cursor] === "revise") {
+                                openReviewerEditor(state.cursor, state.comments[state.cursor] ?? "");
+                                dirty = true;
+                            }
+                        }
+                        else if (state.cursor < issues.length + state.userAdded.length) {
+                            const index = state.cursor - issues.length;
                             state.editing = {
-                                index: state.cursor,
-                                buffer: state.comments[state.cursor] ?? "",
-                                cursor: (state.comments[state.cursor] ?? "").length,
+                                target: { kind: "user-edit", index },
+                                buffer: bufferFromText(state.userAdded[index] ?? ""),
                             };
                             dirty = true;
                         }
+                        else {
+                            openUserAddEditor();
+                            dirty = true;
+                        }
                         continue;
                     }
                     if (event.type === "tab") {
+                        if (state.cursor >= issues.length)
+                            continue;
                         const cur = state.decisions[state.cursor];
                         const next = DECISION_CYCLE[(DECISION_CYCLE.indexOf(cur) + 1) % DECISION_CYCLE.length];
                         state.decisions[state.cursor] = next;
-                        if (next === "revise" && !state.comments[state.cursor]) {
-                            state.editing = { index: state.cursor, buffer: "", cursor: 0 };
+                        if (next === "revise") {
+                            openReviewerEditor(state.cursor);
                         }
                         dirty = true;
                         continue;
                     }
                     if (event.type === "insert") {
+                        if (event.text.toLowerCase() === "a") {
+                            openUserAddEditor();
+                            dirty = true;
+                            continue;
+                        }
                         if (event.text === "n") {
+                            if (state.cursor >= issues.length)
+                                continue;
                             const m = planMetrics(plan, this.host);
                             const citations = issues[state.cursor]?.citations;
                             const targets = findCitationTargets(citations, m.sources);
@@ -215,6 +290,16 @@ export class HostBackedCuratePrompt {
                             dirty = true;
                             continue;
                         }
+                        if (state.cursor === issues.length + state.userAdded.length)
+                            continue;
+                        if (state.cursor >= issues.length) {
+                            if (event.text === "d") {
+                                state.userAdded.splice(state.cursor - issues.length, 1);
+                                clampCursor(issues.length, state);
+                                dirty = true;
+                            }
+                            continue;
+                        }
                         const ch = event.text.toLowerCase();
                         const prev = state.decisions[state.cursor];
                         if (ch === "k")
@@ -225,10 +310,11 @@ export class HostBackedCuratePrompt {
                             state.decisions[state.cursor] = "revise";
                         else
                             continue;
-                        if (state.decisions[state.cursor] === "revise" && !state.comments[state.cursor]) {
-                            state.editing = { index: state.cursor, buffer: "", cursor: 0 };
+                        const openedEditor = state.decisions[state.cursor] === "revise";
+                        if (openedEditor) {
+                            openReviewerEditor(state.cursor);
                         }
-                        if (state.decisions[state.cursor] !== prev)
+                        if (state.decisions[state.cursor] !== prev || openedEditor)
                             dirty = true;
                     }
                 }
@@ -252,45 +338,65 @@ export class HostBackedCuratePrompt {
         });
     }
 }
-function nextCodePointIndex(text, index) {
-    if (index >= text.length)
-        return text.length;
-    const cp = text.codePointAt(index);
-    return index + (cp !== undefined && cp > 0xffff ? 2 : 1);
+function emptyBuffer() {
+    return { lines: [""], cursorRow: 0, cursorCol: 0 };
 }
-function displayWindowForCursor(buffer, cursor, inputWidth) {
-    const clampedCursor = Math.max(0, Math.min(cursor, buffer.length));
-    if (visibleLength(buffer) <= inputWidth) {
-        return {
-            display: buffer,
-            cursorCol: visibleLength(buffer.slice(0, clampedCursor)),
-        };
-    }
-    let start = 0;
-    let prefixWidth = 0;
-    while (start < clampedCursor
-        && visibleLength(buffer.slice(start, clampedCursor)) > inputWidth - prefixWidth) {
-        start = nextCodePointIndex(buffer, start);
-        prefixWidth = start > 0 ? 1 : 0;
-    }
-    if (start > 0)
-        prefixWidth = 1;
-    const bodyWidth = Math.max(0, inputWidth - prefixWidth);
-    while (start < clampedCursor
-        && visibleLength(buffer.slice(start, clampedCursor)) > bodyWidth) {
-        start = nextCodePointIndex(buffer, start);
+function bufferFromText(text) {
+    const lines = text.length > 0 ? text.split("\n") : [""];
+    const cursorRow = Math.max(0, lines.length - 1);
+    return {
+        lines,
+        cursorRow,
+        cursorCol: lines[cursorRow]?.length ?? 0,
+    };
+}
+function normalizeBuffer(buffer) {
+    if (buffer.lines.length === 0)
+        buffer.lines.push("");
+    buffer.cursorRow = Math.max(0, Math.min(buffer.cursorRow, buffer.lines.length - 1));
+    buffer.cursorCol = Math.max(0, Math.min(buffer.cursorCol, buffer.lines[buffer.cursorRow].length));
+}
+function applyCurateTextBufferEvent(editing, event) {
+    normalizeBuffer(editing.buffer);
+    const changed = applyTextBufferEvent(editing.buffer, event);
+    normalizeBuffer(editing.buffer);
+    return changed;
+}
+function navigableCount(issueCount, state) {
+    return issueCount + state.userAdded.length + 1;
+}
+function clampCursor(issueCount, state) {
+    state.cursor = Math.max(0, Math.min(state.cursor, navigableCount(issueCount, state) - 1));
+}
+function renderMultilineEditor(buffer, width, firstPrefix, continuationPrefix) {
+    normalizeBuffer(buffer);
+    const lines = [];
+    const firstPrefixWidth = visibleLength(firstPrefix);
+    const continuationPrefixWidth = visibleLength(continuationPrefix);
+    const bodyWidth = Math.max(1, width - firstPrefixWidth);
+    for (let row = 0; row < buffer.lines.length; row++) {
+        const raw = buffer.lines[row] ?? "";
+        const rendered = renderWrappedLine(raw, bodyWidth, row === buffer.cursorRow ? buffer.cursorCol : null);
+        for (let subRow = 0; subRow < rendered.length; subRow++) {
+            const prefix = row === 0 && subRow === 0 ? firstPrefix : continuationPrefix;
+            lines.push(clipToWidth(`${prefix}${rendered[subRow]}`, width));
+        }
     }
-    let end = start;
-    while (end < buffer.length) {
-        const next = nextCodePointIndex(buffer, end);
-        if (visibleLength(buffer.slice(start, next)) > bodyWidth)
-            break;
-        end = next;
+    const cursorLine = buffer.lines[buffer.cursorRow] ?? "";
+    let cursorRowOffset = 0;
+    for (let row = 0; row < buffer.cursorRow; row++) {
+        cursorRowOffset += softWrapLine(buffer.lines[row] ?? "", bodyWidth).length;
     }
-    const prefix = start > 0 ? "…" : "";
+    const cursorSegments = softWrapLine(cursorLine, bodyWidth);
+    const cursor = cursorToVisual(cursorSegments, buffer.cursorCol, cursorLine.length, bodyWidth);
+    cursorRowOffset += cursor.subRow;
+    const cursorPrefixWidth = buffer.cursorRow === 0 && cursor.subRow === 0
+        ? firstPrefixWidth
+        : continuationPrefixWidth;
     return {
-        display: prefix + buffer.slice(start, end),
-        cursorCol: prefixWidth + visibleLength(buffer.slice(start, clampedCursor)),
+        lines,
+        cursorRowOffset,
+        cursorCol: Math.min(Math.max(0, width - 1), cursorPrefixWidth + cursor.visCol),
     };
 }
 function buildLeftPane(verdict, state, width, rows) {
@@ -305,14 +411,18 @@ function buildLeftPane(verdict, state, width, rows) {
         }
     }
     lines.push("");
-    // Track each issue's header row so we can scroll the left pane to keep
-    // the active issue on screen when the natural surface is taller than
-    // `rows`. Editor placement also feeds into the anchor.
-    const issueStartRows = [];
+    // Every navigable row gets an explicit anchor so scrolling and prompt
+    // cursor placement work for reviewer issues, user-added rows, and the
+    // trailing add row uniformly.
+    const rowStarts = [];
+    const rowEnds = [];
     let editorRow;
     let editorCol = 0;
     for (let i = 0; i < issues.length; i++) {
-        const isCursor = i === state.cursor;
+        if (i > 0)
+            lines.push("");
+        const rowIndex = i;
+        const isCursor = rowIndex === state.cursor;
         const arrow = isCursor ? `${bold}❯${reset}` : " ";
         const tag = tagFor(state.decisions[i]);
         const issue = issues[i];
@@ -327,7 +437,7 @@ function buildLeftPane(verdict, state, width, rows) {
         const metaToken = meta.length ? `${dim}[${meta.join("/")}]${reset}` : "";
         const metaWidth = meta.length ? visibleLength(metaToken) : 0;
         const rendered = renderMarkdown(issue.description, avail);
-        issueStartRows.push(lines.length);
+        rowStarts[rowIndex] = lines.length;
         if (rendered.length === 0) {
             const headRow = metaToken ? `${head}${metaToken}` : head;
             lines.push(clipToWidth(headRow, width));
@@ -353,51 +463,96 @@ function buildLeftPane(verdict, state, width, rows) {
         }
         // Inline revise row(s).
         if (state.decisions[i] === "revise") {
-            const reviseAvail = Math.max(1, width - 4);
-            if (state.editing && state.editing.index === i) {
-                const buf = state.editing.buffer;
-                const prefix = "  └─ Revise: ";
-                const prefixWidth = visibleLength(prefix);
-                const inputWidth = Math.max(1, width - prefixWidth - 1);
-                const window = displayWindowForCursor(buf, state.editing.cursor, inputWidth);
-                const display = applyBlockCursor(window.display, window.cursorCol);
-                const row = `${dim}${prefix}${reset}${display}`;
-                lines.push(clipToWidth(row, width));
-                editorRow = lines.length - 1;
-                editorCol = Math.min(width - 1, prefixWidth + window.cursorCol);
+            const prefix = "  └─ Revise: ";
+            const reviseAvail = Math.max(1, width - visibleLength(prefix));
+            if (state.editing?.target.kind === "reviewer-revise" &&
+                state.editing.target.index === i) {
+                const renderedEditor = renderMultilineEditor(state.editing.buffer, width, `${dim}${prefix}${reset}`, `${dim}${" ".repeat(visibleLength(prefix))}${reset}`);
+                editorRow = lines.length + renderedEditor.cursorRowOffset;
+                editorCol = renderedEditor.cursorCol;
+                lines.push(...renderedEditor.lines);
             }
             else if (state.comments[i]) {
-                const prefix = "  └─ Revise: ";
                 for (const l of wrapToWidth(state.comments[i], reviseAvail)) {
-                    lines.push(`${dim}${prefix}${l}${reset}`);
+                    lines.push(clipToWidth(`${dim}${prefix}${l}${reset}`, width));
                 }
             }
         }
-        if (i < issues.length - 1)
+        rowEnds[rowIndex] = lines.length;
+    }
+    for (let i = 0; i < state.userAdded.length; i++) {
+        const rowIndex = issues.length + i;
+        if (rowIndex > 0)
             lines.push("");
+        const isCursor = rowIndex === state.cursor;
+        const arrow = isCursor ? `${bold}❯${reset}` : " ";
+        const head = `${arrow} ${userAddedTag()} `;
+        const headWidth = visibleLength(head);
+        const avail = Math.max(1, width - headWidth);
+        const indent = " ".repeat(headWidth);
+        rowStarts[rowIndex] = lines.length;
+        if (state.editing?.target.kind === "user-edit" &&
+            state.editing.target.index === i) {
+            const renderedEditor = renderMultilineEditor(state.editing.buffer, width, head, indent);
+            editorRow = lines.length + renderedEditor.cursorRowOffset;
+            editorCol = renderedEditor.cursorCol;
+            lines.push(...renderedEditor.lines);
+        }
+        else {
+            const rendered = renderMarkdown(state.userAdded[i] ?? "", avail);
+            if (rendered.length === 0) {
+                lines.push(clipToWidth(head, width));
+            }
+            else {
+                lines.push(clipToWidth(`${head}${rendered[0]}`, width));
+                for (let j = 1; j < rendered.length; j++) {
+                    lines.push(clipToWidth(`${indent}${rendered[j]}`, width));
+                }
+            }
+        }
+        rowEnds[rowIndex] = lines.length;
+    }
+    {
+        const rowIndex = issues.length + state.userAdded.length;
+        if (rowIndex > 0)
+            lines.push("");
+        const isCursor = rowIndex === state.cursor;
+        const arrow = isCursor ? `${bold}❯${reset}` : " ";
+        rowStarts[rowIndex] = lines.length;
+        if (state.editing?.target.kind === "user-add") {
+            const head = `${arrow} ${userAddedTag()} `;
+            const headWidth = visibleLength(head);
+            const renderedEditor = renderMultilineEditor(state.editing.buffer, width, head, " ".repeat(headWidth));
+            editorRow = lines.length + renderedEditor.cursorRowOffset;
+            editorCol = renderedEditor.cursorCol;
+            lines.push(...renderedEditor.lines);
+        }
+        else {
+            lines.push(clipToWidth(`${arrow} ${dim}+ Add feedback${reset}`, width));
+        }
+        rowEnds[rowIndex] = lines.length;
     }
     lines.push("");
-    const helpStartRow = lines.length;
     const helpRows = [];
     if (state.editing) {
-        helpRows.push("Enter Submit · Esc Cancel");
+        helpRows.push("Ctrl+J Newline · Enter Submit · Esc Cancel");
+    }
+    else if (state.cursor < issues.length) {
+        helpRows.push("↑/↓ Navigate · k/d/r Set · a Add · n Next Citation · Tab Cycle · Enter Edit · Ctrl+D Submit · Ctrl+C Quit");
+    }
+    else if (state.cursor < issues.length + state.userAdded.length) {
+        helpRows.push("↑/↓ Navigate · a Add · Enter Edit · d Delete · Ctrl+D Submit · Ctrl+C Quit");
     }
     else {
-        helpRows.push("↑/↓ Navigate · k/d/r Set · n Next Citation · Tab Cycle · Enter Edit · Ctrl+D Submit · Ctrl+C Quit");
+        helpRows.push("↑/↓ Navigate · Enter/a Add · Ctrl+D Submit · Ctrl+C Quit");
     }
     for (const row of helpRows) {
         for (const l of wrapToWidth(row, width)) {
             lines.push(`${dim}${l}${reset}`);
         }
     }
-    // Scroll the left pane so the active issue stays on screen. Anchor to the
-    // active issue's header row; when the editor is open, also keep the editor
-    // row visible (preferring the editor when both can't fit). Falls back to
-    // scrollTop=0 when the natural surface fits in `rows`.
-    const activeStart = issueStartRows[state.cursor] ?? 0;
-    const activeEndExclusive = state.cursor + 1 < issueStartRows.length
-        ? issueStartRows[state.cursor + 1] - 1 // one before the spacer
-        : helpStartRow - 1; // last issue ends just before the spacer
+    const activeStart = rowStarts[state.cursor] ?? 0;
+    const activeEndExclusive = rowEnds[state.cursor] ?? lines.length;
     // Prefer to show the entire active block; if it is taller than `rows`,
     // fall back to the editor row (when editing) or the header row.
     let scrollTop = 0;
@@ -408,14 +563,17 @@ function buildLeftPane(verdict, state, width, rows) {
         // If the block fits and there is room above, pull the window up so we
         // also include some preceding context rather than leaving blank rows
         // below.
-        if (activeEndExclusive - scrollTop + 1 < rows) {
+        if (activeEndExclusive - scrollTop < rows) {
             scrollTop = Math.max(0, total - rows);
             if (scrollTop > activeStart)
                 scrollTop = activeStart;
         }
         // If editing, prefer keeping the editor row visible.
-        if (editorRow !== undefined && editorRow >= scrollTop + rows) {
-            scrollTop = editorRow - rows + 1;
+        if (editorRow !== undefined) {
+            if (editorRow < scrollTop)
+                scrollTop = editorRow;
+            if (editorRow >= scrollTop + rows)
+                scrollTop = editorRow - rows + 1;
         }
         // Clamp.
         if (scrollTop < 0)