@astralyn/pi 0.87.2 → 0.87.4

package/dist/extensions/todo/view.js

@@ -1,5 +1,5 @@
 /**
- * todo/view.ts — v2 presentation: the one-line above-editor widget renderer,
+ * todo/view.ts — v3 presentation: the one-line above-editor widget renderer,
  * tool call/group renderers, the /todos list formatter, and model-facing
  * result text. Wire input (args, details, snapshots) is read defensively and
  * bounded so partial or hostile input cannot grow output without limit.
@@ -144,39 +144,58 @@ function formatTodoList(state) {
 }
 /** /todos command output: full list, subject line plus indented description per task. */
 export const formatCommandList = formatTodoList;
-/** Model-facing text for one completed todo call; bounded by list and input limits. */
+// --- Model-facing result text ------------------------------------------------
+/** `#1–#3` for a consecutive run, `#1, #2` otherwise. */
+function formatIdRange(ids) {
+    const consecutive = ids.length > 1 && ids.every((id, index) => id === ids[0] + index);
+    return consecutive ? `#${ids[0]}–#${ids[ids.length - 1]}` : ids.map((id) => `#${id}`).join(", ");
+}
+/**
+ * One-line change summary for a completed call, e.g.
+ * `Created 1 task: #7: Wire parser (in_progress); Updated #1 (pending -> completed): S; demoted #5 to pending; auto-removed completed #1–#3 to stay within 20`.
+ * A call that changed nothing (including `{}`) returns the full list.
+ */
 export function formatTodoContent(change, state) {
-    switch (change.kind) {
-        case "create": {
-            const parts = change.ids.map((id) => {
-                const item = state.items.find((entry) => entry.id === id);
-                return item ? `#${item.id}: ${item.subject}` : `#${id}`;
-            });
-            const noun = change.ids.length === 1 ? "task" : "tasks";
-            return `Created ${change.ids.length} ${noun}${parts.length ? `: ${parts.join("; ")}` : ""}`;
-        }
-        case "update": {
-            const item = state.items.find((entry) => entry.id === change.id);
-            const subject = item ? `: ${item.subject}` : "";
-            const transition = change.from === change.to ? "" : ` (${change.from} -> ${change.to})`;
-            const demoted = change.demotedId !== undefined ? `; demoted #${change.demotedId} to pending` : "";
-            return `Updated #${change.id}${transition}${subject}${demoted}`;
-        }
-        case "list":
-            return formatTodoList(state);
-        case "delete": {
-            const noun = change.removed.length === 1 ? "task" : "tasks";
-            const parts = change.removed.map((entry) => `#${entry.id}: ${entry.subject}`);
-            return `Deleted ${change.removed.length} ${noun}${parts.length ? `: ${parts.join("; ")}` : ""}`;
-        }
+    const parts = [];
+    if (change.created.length > 0) {
+        const labels = change.created.map((id) => {
+            const item = state.items.find((entry) => entry.id === id);
+            if (!item)
+                return `#${id}`;
+            const suffix = item.status === "pending" ? "" : ` (${item.status})`;
+            return `#${id}: ${item.subject}${suffix}`;
+        });
+        const noun = change.created.length === 1 ? "task" : "tasks";
+        parts.push(`Created ${change.created.length} ${noun}: ${labels.join("; ")}`);
+    }
+    for (const entry of change.updated) {
+        const item = state.items.find((candidate) => candidate.id === entry.id);
+        const subject = item ? `: ${item.subject}` : "";
+        const transition = entry.from === entry.to ? "" : ` (${entry.from} -> ${entry.to})`;
+        parts.push(`Updated #${entry.id}${transition}${subject}`);
+    }
+    if (change.demotedId !== undefined)
+        parts.push(`demoted #${change.demotedId} to pending`);
+    if (change.deleted.length > 0) {
+        const noun = change.deleted.length === 1 ? "task" : "tasks";
+        const labels = change.deleted.map((entry) => `#${entry.id}: ${entry.subject}`);
+        parts.push(`Deleted ${change.deleted.length} ${noun}: ${labels.join("; ")}`);
+    }
+    for (const id of change.absent)
+        parts.push(`#${id} already absent`);
+    if (change.evicted.length > 0) {
+        const ids = change.evicted.map((entry) => entry.id);
+        parts.push(`auto-removed completed ${formatIdRange(ids)} to stay within ${TODO_MAX_ITEMS}`);
     }
+    if (parts.length === 0)
+        return formatTodoList(state);
+    return parts.join("; ");
 }
 const CALL_ITEMS_MAX = TODO_MAX_BATCH_ITEMS;
 const CALL_SUBJECT_PREVIEW_COUNT = 2;
 const CALL_SUBJECT_PREVIEW_WIDTH = 72;
 const CALL_DESCRIPTION_PREVIEW_LENGTH = 120;
 const GROUP_FAILURE_MAX_LENGTH = 120;
-const TODO_ACTIONS = new Set(["create", "update", "list", "delete"]);
 /** Record-like read; proxies that throw on inspection are treated as absent. */
 function safeRecord(value) {
     try {
@@ -235,36 +254,55 @@ function readArray(value, limit = CALL_ITEMS_MAX) {
         return undefined;
     }
 }
-/** Id lists: lenient for delete args (invalid entries drop), strict for result changes (any invalid entry rejects). */
-function readIds(value, strict) {
+/** Id lists: invalid entries drop (rendering never rejects the whole call). */
+function readIds(value) {
     const array = readArray(value);
-    if (strict && (!array || array.length === 0 || array.length > CALL_ITEMS_MAX))
-        return undefined;
     if (!array)
-        return strict ? undefined : [];
+        return undefined;
     const ids = [];
     for (const entry of array.values) {
         const id = safeId(entry);
-        if (id === undefined) {
-            if (strict)
-                return undefined;
-            continue;
-        }
-        ids.push(id);
+        if (id !== undefined)
+            ids.push(id);
     }
     return ids;
 }
 /** Create args: sparse or invalid entries drop; the batch caps at the maximum. */
-function batchItems(value) {
+function batchCreateItems(value) {
     const result = [];
     for (const raw of readArray(value)?.values ?? []) {
         const item = safeRecord(raw);
         if (!item)
             continue;
-        result.push({
+        const entry = {
             subject: safeSubject(safeValue(item, "subject")),
             description: safeDescription(safeValue(item, "description")),
-        });
+        };
+        const status = safeStatus(safeValue(item, "status"));
+        if (status)
+            entry.status = status;
+        result.push(entry);
+    }
+    return result;
+}
+/** Update args: sparse or invalid entries drop; the batch caps at the maximum. */
+function batchUpdateItems(value) {
+    const result = [];
+    for (const raw of readArray(value)?.values ?? []) {
+        const item = safeRecord(raw);
+        if (!item)
+            continue;
+        const entry = {
+            subject: safeSubject(safeValue(item, "subject")),
+            description: safeDescription(safeValue(item, "description")),
+        };
+        const id = safeId(safeValue(item, "id"));
+        if (id !== undefined)
+            entry.id = id;
+        const status = safeStatus(safeValue(item, "status"));
+        if (status)
+            entry.status = status;
+        result.push(entry);
     }
     return result;
 }
@@ -287,7 +325,7 @@ function formatSubjectPreview(subjects, total) {
     const hidden = Math.max(0, total - shown.length);
     return `${shown.join(", ")}${hidden ? `, +${hidden} more` : ""}`;
 }
-/** v2 details guard shared by the call and group renderers. */
+/** v3 details guard shared by the call and group renderers. */
 function todoDetails(value) {
     const details = safeRecord(value);
     if (!details || safeValue(details, "schemaVersion") !== TODO_DETAILS_SCHEMA_VERSION)
@@ -296,83 +334,118 @@ function todoDetails(value) {
     const state = safeRecord(safeValue(details, "state"));
     if (!change || !state)
         return undefined;
-    const kind = safeString(safeValue(change, "kind"));
-    if (!kind || !TODO_ACTIONS.has(kind))
-        return undefined;
     return { change, state };
 }
 /** Result ids for an expanded create, only when they match the shown items. */
 function createResultIds(result, count) {
     const details = todoDetails(result?.details);
-    if (!details || safeString(safeValue(details.change, "kind")) !== "create")
+    if (!details)
         return undefined;
-    const ids = readIds(safeValue(details.change, "ids"), true);
-    return ids?.length === count ? ids : undefined;
+    const ids = readIds(safeValue(details.change, "created"));
+    return ids && ids.length === count && count > 0 ? ids : undefined;
 }
-/** Removed entries for an expanded delete; absent until a v2 delete result arrives. */
+/** Removed entries from a settled result, for the expanded delete detail lines. */
 function deleteResultRemoved(result) {
     const details = todoDetails(result?.details);
-    if (!details || safeString(safeValue(details.change, "kind")) !== "delete")
-        return undefined;
-    return removedEntries(safeValue(details.change, "removed"));
+    if (!details)
+        return [];
+    return idSubjectEntries(safeValue(details.change, "deleted"));
+}
+/** Absent ids from a settled delete, for the expanded delete detail lines. */
+function deleteResultAbsent(result) {
+    const details = todoDetails(result?.details);
+    if (!details)
+        return [];
+    return readIds(safeValue(details.change, "absent")) ?? [];
 }
 /** Headline plus the parameters the result never echoes as detail lines. */
 function formatCallParts(args, theme, result) {
-    const action = clipText(args?.action, TODO_MAX_SUBJECT_LENGTH);
-    const verb = TODO_ACTIONS.has(action) ? action : undefined;
-    const headline = [theme.fg("toolTitle", theme.bold(verb ? `todo ${verb}` : "todo"))];
     const details = [];
-    if (verb === "create") {
-        const items = batchItems(args?.items);
-        const rawCount = readArray(args?.items)?.length;
-        if (rawCount !== undefined) {
-            const count = Math.min(rawCount, CALL_ITEMS_MAX);
-            headline.push(theme.fg("dim", `${count} ${count === 1 ? "task" : "tasks"}`));
-            const subjects = items.map((item) => item.subject);
-            const preview = formatSubjectPreview(subjects, count);
-            if (preview)
-                headline.push(theme.fg("dim", "·"), theme.fg("text", preview));
+    const segments = [];
+    const pushSegment = (verb, body) => {
+        const title = segments.length === 0 ? `todo ${verb}` : verb;
+        segments.push(body ? `${theme.fg("toolTitle", theme.bold(title))} ${body}` : theme.fg("toolTitle", theme.bold(title)));
+    };
+    const hasCreate = args?.create !== undefined;
+    const hasUpdate = args?.update !== undefined;
+    const hasDelete = args?.delete !== undefined;
+    if (hasCreate) {
+        const items = batchCreateItems(args?.create);
+        const rawCount = readArray(args?.create)?.length;
+        // An empty array is strict-mode filler: the call lists the tasks, so the
+        // group earns no segment of its own.
+        if (rawCount !== 0) {
+            const body = [];
+            if (rawCount !== undefined) {
+                const count = Math.min(rawCount, CALL_ITEMS_MAX);
+                body.push(theme.fg("dim", `${count} ${count === 1 ? "task" : "tasks"}`));
+                const preview = formatSubjectPreview(items.map((item) => item.subject), count);
+                if (preview)
+                    body.push(theme.fg("dim", "·"), theme.fg("text", preview));
+            }
+            pushSegment("create", body.join(" "));
         }
         const ids = createResultIds(result, items.length);
         for (const [index, item] of items.entries()) {
             const marker = ids ? theme.fg("accent", `#${ids[index]}`) : theme.fg("accent", `${index + 1}.`);
-            details.push(item.subject ? `${marker} ${theme.fg("text", item.subject)}` : marker);
+            const status = item.status && item.status !== "pending"
+                ? ` ${theme.fg(STATUS_COLOR[item.status], `(${item.status})`)}`
+                : "";
+            details.push(item.subject ? `${marker} ${theme.fg("text", item.subject)}${status}` : marker);
             if (item.description)
                 details.push(`    ${theme.fg("dim", descriptionPreview(item.description))}`);
         }
     }
-    else if (verb === "update") {
-        const id = safeId(args?.id);
-        if (id !== undefined)
-            headline.push(theme.fg("accent", `#${id}`));
-        const status = safeStatus(args?.status);
-        if (status)
-            headline.push(theme.fg(STATUS_COLOR[status], status));
-        const subject = safeSubject(args?.subject);
-        if (subject)
-            headline.push(theme.fg("text", truncateToWidth(subject, CALL_SUBJECT_PREVIEW_WIDTH, "…")));
-        const description = safeDescription(args?.description);
-        if (description)
-            details.push(`    ${theme.fg("dim", descriptionPreview(description))}`);
+    if (hasUpdate) {
+        const items = batchUpdateItems(args?.update);
+        const rawCount = readArray(args?.update)?.length;
+        if (rawCount !== 0) {
+            const entries = [];
+            for (const item of items) {
+                const parts = [];
+                if (item.id !== undefined)
+                    parts.push(theme.fg("accent", `#${item.id}`));
+                if (item.status)
+                    parts.push(theme.fg(STATUS_COLOR[item.status], item.status));
+                if (item.subject)
+                    parts.push(theme.fg("text", truncateToWidth(item.subject, CALL_SUBJECT_PREVIEW_WIDTH, "…")));
+                if (parts.length > 0)
+                    entries.push(parts.join(" "));
+            }
+            pushSegment("update", entries.join(theme.fg("dim", ", ")));
+        }
+        for (const item of items) {
+            if (item.description)
+                details.push(`    ${theme.fg("dim", descriptionPreview(item.description))}`);
+        }
     }
-    else if (verb === "delete") {
-        const ids = readIds(args?.ids, false) ?? [];
-        if (ids.length)
-            headline.push(theme.fg("accent", ids.map((id) => `#${id}`).join(", ")));
-        // The headline already carries the ids, so details only earn their line
-        // once the result names what was actually removed.
-        for (const entry of deleteResultRemoved(result) ?? []) {
+    if (hasDelete) {
+        const rawCount = readArray(args?.delete)?.length;
+        if (rawCount !== 0) {
+            const ids = readIds(args?.delete) ?? [];
+            pushSegment("delete", ids.length > 0 ? theme.fg("accent", ids.map((id) => `#${id}`).join(", ")) : "");
+        }
+        // The headline already carries the ids, so details only earn their lines
+        // once the result names what was actually removed or already absent.
+        for (const entry of deleteResultRemoved(result)) {
             details.push(`${theme.fg("accent", `#${entry.id}`)} ${theme.fg("text", entry.subject)}`);
         }
+        for (const id of deleteResultAbsent(result)) {
+            details.push(theme.fg("dim", `#${id} already absent`));
+        }
     }
-    return { headline: headline.join(" "), details };
+    if (segments.length === 0) {
+        // No group fields at all: the call lists the tasks.
+        segments.push(theme.fg("toolTitle", theme.bold("todo list")));
+    }
+    return { headline: segments.join(theme.fg("dim", " ; ")), details };
 }
 /** One-line call summary when collapsed; headline plus details when expanded. */
 export function formatTodoCall(args, theme, expanded, result) {
     const { headline, details } = formatCallParts(args, theme, result);
     return !expanded || details.length === 0 ? headline : [headline, ...details].join("\n");
 }
-/** Id -> item index plus status counts over the v2 snapshot (one defensive walk). */
+/** Id -> item index plus status counts over the v3 snapshot (one defensive walk). */
 function stateIndex(state) {
     const array = readArray(safeValue(state, "items"), TODO_MAX_ITEMS);
     if (!array || array.length > TODO_MAX_ITEMS)
@@ -400,81 +473,98 @@ function stateSubject(map, id) {
     const item = map.get(id);
     return item ? safeSubject(safeValue(item, "subject")) : "";
 }
-/** Deleted entries: one invalid or empty entry rejects the whole list. */
-function removedEntries(value) {
-    const array = readArray(value);
-    if (!array || array.length === 0 || array.length > CALL_ITEMS_MAX)
-        return undefined;
-    const removed = [];
-    for (const raw of array.values) {
-        const id = safeId(safeValue(safeRecord(raw), "id"));
-        const subject = safeSubject(safeValue(safeRecord(raw), "subject"));
+/** Id+subject entries (deleted, evicted): invalid entries drop. */
+function idSubjectEntries(value) {
+    const entries = [];
+    for (const raw of readArray(value)?.values ?? []) {
+        const item = safeRecord(raw);
+        const id = safeId(safeValue(item, "id"));
+        const subject = safeSubject(safeValue(item, "subject"));
         if (id === undefined || !subject)
-            return undefined;
-        removed.push({ id, subject });
+            continue;
+        entries.push({ id, subject });
+    }
+    return entries;
+}
+/** Updated entries: {id, from, to} records, invalid entries drop. */
+function updatedEntries(value) {
+    const entries = [];
+    for (const raw of readArray(value)?.values ?? []) {
+        const item = safeRecord(raw);
+        const id = safeId(safeValue(item, "id"));
+        if (id === undefined)
+            continue;
+        const entry = { id };
+        const from = safeStatus(safeValue(item, "from"));
+        if (from)
+            entry.from = from;
+        const to = safeStatus(safeValue(item, "to"));
+        if (to)
+            entry.to = to;
+        entries.push(entry);
     }
-    return removed;
+    return entries;
 }
 function formatTodoGroupSuccess(args, theme, result) {
     const parsed = todoDetails(result.details);
     if (!parsed)
         return undefined;
     const { change, state } = parsed;
-    const verb = (word) => theme.fg("toolTitle", `todo ${word}`);
+    const index = stateIndex(state);
+    const segments = [];
+    const pushVerb = (word, body) => {
+        const title = segments.length === 0 ? `todo ${word}` : word;
+        segments.push(body ? `${theme.fg("toolTitle", title)} ${body}` : theme.fg("toolTitle", title));
+    };
     const withPreview = (word, ids, subjects) => {
         const text = formatSubjectPreview(subjects, subjects.length);
-        const consecutive = ids.length > 1 && ids.every((id, index) => id === ids[0] + index);
-        const rendered = consecutive ? `#${ids[0]}–#${ids.at(-1)}` : ids.map((id) => `#${id}`).join(", ");
-        const base = `${verb(word)} ${theme.fg("accent", rendered)}`;
-        return text ? `${base}${theme.fg("dim", " · ")}${theme.fg("text", text)}` : base;
+        const base = theme.fg("accent", formatIdRange(ids));
+        pushVerb(word, text ? `${base}${theme.fg("dim", " · ")}${theme.fg("text", text)}` : base);
     };
-    const kind = safeString(safeValue(change, "kind"));
-    if (kind === "create") {
-        const ids = readIds(safeValue(change, "ids"), true);
-        const index = stateIndex(state);
-        if (!ids || !index)
-            return undefined;
-        const subjects = ids.map((id) => stateSubject(index.byId, id));
-        return withPreview("created", ids, subjects);
+    const created = readIds(safeValue(change, "created")) ?? [];
+    if (created.length > 0 && index) {
+        withPreview("created", created, created.map((id) => stateSubject(index.byId, id)));
     }
-    if (kind === "update") {
-        const id = safeId(safeValue(change, "id"));
-        const index = stateIndex(state);
-        if (id === undefined || !index)
-            return undefined;
-        const to = safeStatus(safeValue(change, "to"));
-        const demotedId = safeId(safeValue(change, "demotedId"));
-        const parts = [verb("updated"), theme.fg("accent", `#${id}`)];
-        if (to)
-            parts.push(theme.fg(STATUS_COLOR[to], to));
-        const subject = stateSubject(index.byId, id) || safeSubject(args?.subject) || "";
+    for (const entry of updatedEntries(safeValue(change, "updated"))) {
+        const parts = [theme.fg("accent", `#${entry.id}`)];
+        if (entry.to)
+            parts.push(theme.fg(STATUS_COLOR[entry.to], entry.to));
+        const subject = index ? stateSubject(index.byId, entry.id) : "";
         if (subject)
             parts.push(theme.fg("text", truncateToWidth(subject, CALL_SUBJECT_PREVIEW_WIDTH, "…")));
-        if (demotedId !== undefined)
-            parts.push(theme.fg("dim", `· demoted #${demotedId}`));
-        return parts.join(" ");
+        pushVerb("updated", parts.join(" "));
     }
-    if (kind === "list") {
-        const counts = stateIndex(state)?.counts;
-        if (!counts)
-            return undefined;
-        const parts = [];
-        if (counts.inProgress > 0)
-            parts.push(`${counts.inProgress} in progress`);
-        if (counts.pending > 0)
-            parts.push(`${counts.pending} pending`);
-        if (counts.completed > 0)
-            parts.push(`${counts.completed} completed`);
-        return `${verb("list")}: ${theme.fg("dim", parts.length ? parts.join(", ") : "no tasks")}`;
+    const demotedId = safeId(safeValue(change, "demotedId"));
+    if (demotedId !== undefined)
+        segments.push(theme.fg("dim", `demoted #${demotedId}`));
+    const deleted = idSubjectEntries(safeValue(change, "deleted"));
+    if (deleted.length > 0) {
+        withPreview("deleted", deleted.map((entry) => entry.id), deleted.map((entry) => entry.subject));
     }
-    if (kind === "delete") {
-        const removed = removedEntries(safeValue(change, "removed"));
-        if (!removed)
+    for (const id of readIds(safeValue(change, "absent")) ?? []) {
+        segments.push(theme.fg("dim", `#${id} already absent`));
+    }
+    const evicted = idSubjectEntries(safeValue(change, "evicted"));
+    if (evicted.length > 0) {
+        segments.push(theme.fg("dim", `auto-removed ${evicted.map((entry) => `#${entry.id}`).join(", ")}`));
+    }
+    if (segments.length === 0) {
+        // Empty change: the call listed the tasks.
+        if (!index)
             return undefined;
-        const subjects = removed.map((entry) => entry.subject);
-        return withPreview("deleted", removed.map((entry) => entry.id), subjects);
+        const parts = [];
+        if (index.counts.inProgress > 0)
+            parts.push(`${index.counts.inProgress} in progress`);
+        if (index.counts.pending > 0)
+            parts.push(`${index.counts.pending} pending`);
+        if (index.counts.completed > 0)
+            parts.push(`${index.counts.completed} completed`);
+        return `${theme.fg("toolTitle", "todo list")}: ${theme.fg("dim", parts.length ? parts.join(", ") : "no tasks")}`;
     }
-    return undefined;
+    // The update segment can still pick up the requested subject when the state
+    // no longer holds it (e.g. the task was deleted by a hostile snapshot).
+    void args;
+    return segments.join(theme.fg("dim", " ; "));
 }
 /** Compact result-aware summary used only by collapsed todo tool groups. */
 export function formatTodoGroupCall(args, theme, context) {