can1357
b9cfff73ec
- Removed the todo bar collapse timer and related animation logic from interactive mode. - Simplified todo list rendering by removing collapse fraction calculations.
389 lines
14 KiB
TypeScript
389 lines
14 KiB
TypeScript
import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "bun:test";
|
|
import * as path from "node:path";
|
|
import { Agent } from "@oh-my-pi/pi-agent-core";
|
|
import { ModelRegistry } from "@oh-my-pi/pi-coding-agent/config/model-registry";
|
|
import { resetSettingsForTest, Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
|
|
import { InteractiveMode } from "@oh-my-pi/pi-coding-agent/modes/interactive-mode";
|
|
import { initTheme, theme } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
|
|
import { AgentSession } from "@oh-my-pi/pi-coding-agent/session/agent-session";
|
|
import { AuthStorage } from "@oh-my-pi/pi-coding-agent/session/auth-storage";
|
|
import { SessionManager } from "@oh-my-pi/pi-coding-agent/session/session-manager";
|
|
import { TASK_SUBAGENT_LIFECYCLE_CHANNEL } from "@oh-my-pi/pi-coding-agent/task";
|
|
import type { TodoPhase } from "@oh-my-pi/pi-coding-agent/tools/todo";
|
|
import { EventBus } from "@oh-my-pi/pi-coding-agent/utils/event-bus";
|
|
import type { NativeScrollbackLiveRegion } from "@oh-my-pi/pi-tui";
|
|
import { TempDir } from "@oh-my-pi/pi-utils";
|
|
|
|
function renderTodos(mode: InteractiveMode): string {
|
|
return Bun.stripANSI(mode.todoContainer.render(120).join("\n"));
|
|
}
|
|
|
|
describe("InteractiveMode todo HUD persistence", () => {
|
|
let tempDir: TempDir;
|
|
let authStorage: AuthStorage;
|
|
let session: AgentSession;
|
|
let mode: InteractiveMode;
|
|
let eventBus: EventBus;
|
|
let modelRegistry: ModelRegistry;
|
|
|
|
async function replaceMode(): Promise<void> {
|
|
if (mode) {
|
|
mode.stop();
|
|
await session.dispose();
|
|
}
|
|
const model = modelRegistry.find("anthropic", "claude-sonnet-4-5");
|
|
if (!model) throw new Error("Expected claude-sonnet-4-5 to exist in registry");
|
|
eventBus = new EventBus();
|
|
session = new AgentSession({
|
|
agent: new Agent({
|
|
initialState: {
|
|
model,
|
|
systemPrompt: ["Test"],
|
|
tools: [],
|
|
messages: [],
|
|
},
|
|
}),
|
|
sessionManager: SessionManager.create(tempDir.path(), tempDir.path()),
|
|
settings: Settings.isolated(),
|
|
modelRegistry,
|
|
});
|
|
mode = new InteractiveMode(session, "test", undefined, undefined, undefined, undefined, eventBus);
|
|
}
|
|
|
|
beforeAll(async () => {
|
|
await initTheme();
|
|
resetSettingsForTest();
|
|
tempDir = TempDir.createSync("@pi-todo-clear-");
|
|
await Settings.init({ inMemory: true, cwd: tempDir.path() });
|
|
authStorage = await AuthStorage.create(path.join(tempDir.path(), "testauth.db"));
|
|
modelRegistry = new ModelRegistry(authStorage);
|
|
await replaceMode();
|
|
});
|
|
|
|
afterEach(() => {
|
|
session.setTodoPhases([]);
|
|
mode.setTodos([]);
|
|
vi.useRealTimers();
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
mode?.stop();
|
|
await session?.dispose();
|
|
authStorage?.close();
|
|
tempDir?.removeSync();
|
|
resetSettingsForTest();
|
|
});
|
|
|
|
function setTodoClearDelay(todoClearDelay: number): void {
|
|
session.settings.override("tasks.todoClearDelay", todoClearDelay);
|
|
}
|
|
|
|
it("clears closed todos from the panel instantly without mutating session history", () => {
|
|
setTodoClearDelay(0);
|
|
const phases: TodoPhase[] = [
|
|
{
|
|
name: "Implementation",
|
|
tasks: [
|
|
{ content: "done task", status: "completed" },
|
|
{ content: "abandoned task", status: "abandoned" },
|
|
],
|
|
},
|
|
];
|
|
session.setTodoPhases(phases);
|
|
|
|
mode.setTodos(session.getTodoPhases());
|
|
|
|
expect(renderTodos(mode)).not.toContain("done task");
|
|
expect(renderTodos(mode)).not.toContain("abandoned task");
|
|
expect(session.getTodoPhases()).toEqual(phases);
|
|
});
|
|
|
|
/**
|
|
* Auto-clear used to fire on any list holding a closed task, so a plan the
|
|
* agent was mid-way through had its finished tasks deleted from the HUD's
|
|
* copy: the phase counter reset, the checked row vanished, and the stage
|
|
* renumbered — the panel reported no progress at all until the next `todo`
|
|
* call restored the real snapshot. It may only fire on a settled list.
|
|
*/
|
|
const unfinishedPlan = (): TodoPhase[] => [
|
|
{
|
|
name: "Implementation",
|
|
tasks: [
|
|
{ content: "done task", status: "completed" },
|
|
{ content: "abandoned task", status: "abandoned" },
|
|
{ content: "current task", status: "in_progress" },
|
|
],
|
|
},
|
|
];
|
|
|
|
it("keeps an unfinished plan's progress when the auto-clear delay elapses", () => {
|
|
setTodoClearDelay(1);
|
|
vi.useFakeTimers();
|
|
|
|
mode.setTodos(unfinishedPlan());
|
|
vi.advanceTimersByTime(60_000);
|
|
|
|
const rendered = renderTodos(mode);
|
|
// Progress counts every closed task, abandoned included: the walking
|
|
// viewport hides both, so the counter is the only signal they existed.
|
|
expect(rendered).toContain("2/3");
|
|
expect(rendered).toContain("current task");
|
|
});
|
|
|
|
it("keeps an unfinished plan's progress when auto-clear is instant", () => {
|
|
setTodoClearDelay(0);
|
|
|
|
mode.setTodos(unfinishedPlan());
|
|
|
|
const rendered = renderTodos(mode);
|
|
expect(rendered).toContain("2/3");
|
|
expect(rendered).toContain("current task");
|
|
});
|
|
|
|
it("leaves closed todos visible when auto-clear is disabled", () => {
|
|
setTodoClearDelay(-1);
|
|
|
|
mode.setTodos([{ name: "Implementation", tasks: [{ content: "done task", status: "completed" }] }]);
|
|
|
|
expect(renderTodos(mode)).toContain("done task");
|
|
});
|
|
|
|
it("clears closed todos after the configured delay", () => {
|
|
setTodoClearDelay(1);
|
|
vi.useFakeTimers();
|
|
|
|
mode.setTodos([{ name: "Implementation", tasks: [{ content: "done task", status: "completed" }] }]);
|
|
expect(renderTodos(mode)).toContain("done task");
|
|
|
|
vi.advanceTimersByTime(999);
|
|
expect(renderTodos(mode)).toContain("done task");
|
|
expect(renderTodos(mode)).toContain("TODO");
|
|
|
|
vi.advanceTimersByTime(1);
|
|
expect(renderTodos(mode)).not.toContain("done task");
|
|
});
|
|
|
|
it("keeps the anchored todo panel in the live region while visible", () => {
|
|
setTodoClearDelay(-1);
|
|
|
|
mode.setTodos([{ name: "Implementation", tasks: [{ content: "pending task", status: "pending" }] }]);
|
|
const liveRegion = mode.todoContainer as unknown as NativeScrollbackLiveRegion;
|
|
expect(liveRegion.getNativeScrollbackLiveRegionStart?.()).toBe(0);
|
|
|
|
mode.setTodos([]);
|
|
expect(liveRegion.getNativeScrollbackLiveRegionStart?.()).toBeUndefined();
|
|
});
|
|
|
|
it("marks todos complete when subagent reconciliation reports a finished agent", async () => {
|
|
await replaceMode();
|
|
setTodoClearDelay(-1);
|
|
vi.spyOn(mode.statusLine, "watchBranch").mockImplementation(() => {});
|
|
session.setTodoPhases([
|
|
{ name: "Implementation", tasks: [{ content: "Fix review comments", status: "pending" }] },
|
|
]);
|
|
mode.setTodos(session.getTodoPhases());
|
|
|
|
await mode.init();
|
|
// Subagent lifecycle changes coalesce behind a 100ms observer UI sync
|
|
// timer before todo reconciliation runs; flush it deterministically.
|
|
vi.useFakeTimers();
|
|
eventBus.emit(TASK_SUBAGENT_LIFECYCLE_CHANNEL, {
|
|
id: "ReviewFixer",
|
|
index: 0,
|
|
agent: "task",
|
|
description: "Fix review comments",
|
|
status: "completed",
|
|
detached: true,
|
|
});
|
|
vi.advanceTimersByTime(100);
|
|
|
|
expect(session.getTodoPhases()[0]?.tasks[0]?.status).toBe("completed");
|
|
});
|
|
|
|
it("completes a blocked todo when the detached subagent it waits on finishes", async () => {
|
|
await replaceMode();
|
|
setTodoClearDelay(-1);
|
|
vi.spyOn(mode.statusLine, "watchBranch").mockImplementation(() => {});
|
|
// A todo blocked while waiting on a detached subagent. Blocked todos are
|
|
// excluded from the stop reminder, so if reconciliation skipped them this
|
|
// would strand silently after the subagent completes.
|
|
session.setTodoPhases([
|
|
{
|
|
name: "Implementation",
|
|
tasks: [{ content: "Fix review comments", status: "blocked", blocker: "waiting on ReviewFixer" }],
|
|
},
|
|
]);
|
|
mode.setTodos(session.getTodoPhases());
|
|
|
|
await mode.init();
|
|
vi.useFakeTimers();
|
|
eventBus.emit(TASK_SUBAGENT_LIFECYCLE_CHANNEL, {
|
|
id: "ReviewFixer",
|
|
index: 0,
|
|
agent: "task",
|
|
description: "Fix review comments",
|
|
status: "completed",
|
|
detached: true,
|
|
});
|
|
vi.advanceTimersByTime(100);
|
|
|
|
const task = session.getTodoPhases()[0]?.tasks[0];
|
|
expect(task?.status).toBe("completed");
|
|
// The blocker note is dropped with the blocked status — the wait is over.
|
|
expect(task?.blocker).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe("InteractiveMode todo HUD anchor", () => {
|
|
let tempDir: TempDir;
|
|
let authStorage: AuthStorage;
|
|
let session: AgentSession;
|
|
let mode: InteractiveMode;
|
|
|
|
beforeAll(async () => {
|
|
await initTheme();
|
|
resetSettingsForTest();
|
|
tempDir = TempDir.createSync("@pi-todo-hud-");
|
|
await Settings.init({ inMemory: true, cwd: tempDir.path() });
|
|
authStorage = await AuthStorage.create(path.join(tempDir.path(), "testauth.db"));
|
|
const modelRegistry = new ModelRegistry(authStorage);
|
|
const model = modelRegistry.find("anthropic", "claude-sonnet-4-5");
|
|
if (!model) throw new Error("Expected claude-sonnet-4-5 to exist in registry");
|
|
session = new AgentSession({
|
|
agent: new Agent({
|
|
initialState: { model, systemPrompt: ["Test"], tools: [], messages: [] },
|
|
}),
|
|
sessionManager: SessionManager.create(tempDir.path(), tempDir.path()),
|
|
settings: Settings.isolated({}),
|
|
modelRegistry,
|
|
});
|
|
mode = new InteractiveMode(session, "test");
|
|
});
|
|
|
|
afterEach(() => {
|
|
mode.setTodos([]);
|
|
vi.useRealTimers();
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
mode?.stop();
|
|
await session?.dispose();
|
|
authStorage?.close();
|
|
tempDir?.removeSync();
|
|
resetSettingsForTest();
|
|
});
|
|
|
|
it("renders a Todos tree: stage progression header, active stage expanded, others collapsed", () => {
|
|
mode.setTodos([
|
|
{
|
|
name: "Foundation",
|
|
tasks: [
|
|
{ content: "first task", status: "completed" },
|
|
{ content: "second task", status: "in_progress" },
|
|
{ content: "third task", status: "pending" },
|
|
],
|
|
},
|
|
{
|
|
name: "Verification",
|
|
tasks: [{ content: "run tests", status: "pending" }],
|
|
},
|
|
]);
|
|
|
|
const lines = mode.todoContainer
|
|
.render(80)
|
|
.flatMap(line => line.split("\n"))
|
|
.map(line => Bun.stripANSI(line));
|
|
|
|
// Lightened: no boxed top/bottom rules.
|
|
expect(lines.some(line => line === "─".repeat(80))).toBe(false);
|
|
// The title remains a compact anchor; overall progress colors the tree
|
|
// spine and tail, not the title text.
|
|
const root = lines.find(line => line.includes("TODO"));
|
|
expect(root?.trim()).toBe("TODO");
|
|
// Active stage: highlighted header with its own task progress, expanded as a
|
|
// connector tree; the just-completed task stays as the lead row so progress
|
|
// is visible while the stage still has open work.
|
|
expect(lines.some(line => line.includes("I. Foundation") && line.includes("1/3"))).toBe(true);
|
|
const secondLine = lines.find(line => line.includes("second task"));
|
|
expect(secondLine).toContain(theme.tree.branch);
|
|
expect(secondLine).toContain(theme.checkbox.unchecked);
|
|
expect(lines.some(line => line.includes("third task"))).toBe(true);
|
|
const firstLine = lines.find(line => line.includes("first task"));
|
|
expect(firstLine).toContain(theme.checkbox.checked);
|
|
// Upcoming stage: header with its own progress, but collapsed (no task rows).
|
|
expect(lines.some(line => line.includes("II. Verification") && line.includes("0/1"))).toBe(true);
|
|
expect(lines.some(line => line.includes("run tests"))).toBe(false);
|
|
// No overflow rows — the header/progress counts imply what is hidden.
|
|
expect(lines.some(line => line.includes("more"))).toBe(false);
|
|
});
|
|
|
|
it("renders nothing when there are no todos", () => {
|
|
mode.setTodos([]);
|
|
expect(mode.todoContainer.render(80)).toHaveLength(0);
|
|
});
|
|
|
|
it("keeps the summed progress bar but omits the roman numeral for a single-phase list", () => {
|
|
mode.setTodos([
|
|
{
|
|
name: "Tasks",
|
|
tasks: [
|
|
{ content: "alpha", status: "pending" },
|
|
{ content: "beta", status: "pending" },
|
|
],
|
|
},
|
|
]);
|
|
const lines = mode.todoContainer
|
|
.render(80)
|
|
.flatMap(line => line.split("\n"))
|
|
.map(line => Bun.stripANSI(line));
|
|
// One stage still renders the compact title; progress belongs to the
|
|
// tree spine and tail.
|
|
const root = lines.find(line => line.includes("TODO"));
|
|
expect(root?.trim()).toBe("TODO");
|
|
// The stage keeps its task progress; no roman numeral for a lone stage.
|
|
expect(lines.some(line => line.includes("Tasks") && line.includes("0/2"))).toBe(true);
|
|
expect(lines.some(line => line.includes("I. Tasks"))).toBe(false);
|
|
expect(lines.some(line => line.includes("alpha"))).toBe(true);
|
|
});
|
|
|
|
it("caps the visible stage list and summarizes the hidden ones in an overflow row", () => {
|
|
const stage = (name: string): TodoPhase => ({ name, tasks: [{ content: `${name} task`, status: "pending" }] });
|
|
mode.setTodos([
|
|
stage("Discovery"),
|
|
stage("Two"),
|
|
stage("Three"),
|
|
stage("Four"),
|
|
stage("Five"),
|
|
stage("Six"),
|
|
stage("Seven"),
|
|
]);
|
|
const lines = mode.todoContainer
|
|
.render(80)
|
|
.flatMap(line => line.split("\n"))
|
|
.map(line => Bun.stripANSI(line));
|
|
// Active stage + four following stages render; the rest collapse into a
|
|
// trailing "… n more stages" row.
|
|
expect(lines.some(line => line.includes("II. Two"))).toBe(true);
|
|
expect(lines.some(line => line.includes("V. Five"))).toBe(true);
|
|
expect(lines.some(line => line.includes("Six"))).toBe(false);
|
|
expect(lines.some(line => line.includes("2 more stages"))).toBe(true);
|
|
// Hidden stages do not change the compact title.
|
|
const root = lines.find(line => line.includes("TODO"));
|
|
expect(root?.trim()).toBe("TODO");
|
|
});
|
|
|
|
it("anchors the todo HUD as a native-scrollback live region while populated", () => {
|
|
// The loader sits below this HUD, so the HUD must report its own seam or
|
|
// its rows commit to scrollback as stale duplicates on short terminals.
|
|
const seam = () =>
|
|
(mode.todoContainer as Partial<NativeScrollbackLiveRegion>).getNativeScrollbackLiveRegionStart?.();
|
|
expect(seam()).toBeUndefined();
|
|
mode.setTodos([{ name: "Tasks", tasks: [{ content: "alpha", status: "pending" }] }]);
|
|
expect(seam()).toBe(0);
|
|
mode.setTodos([]);
|
|
expect(seam()).toBeUndefined();
|
|
});
|
|
});
|