pi-plan-task 1.1.0 → 4.0.0

package/extensions/build-session.test.ts

@@ -1,35 +1,33 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { parseBuildPlacement, parseGoalMode } from "./build-session.ts";
+import { parseBuildOptions } from "./build-session.ts";
 
-describe("parseBuildPlacement", () => {
-	it("stays in this session by default", () => {
-		assert.equal(parseBuildPlacement(""), "here");
-		assert.equal(parseBuildPlacement("  "), "here");
-		assert.equal(parseBuildPlacement("unknown"), "here");
-		assert.equal(parseBuildPlacement("here"), "here");
-		assert.equal(parseBuildPlacement(" --here extra"), "here");
-	});
+function options(input: string) {
+	const result = parseBuildOptions(input);
+	assert.equal(result.ok, true);
+	if (!result.ok) throw new Error("Expected build options to parse");
+	return result.options;
+}
 
-	it("accepts new aliases", () => {
-		assert.equal(parseBuildPlacement("new"), "new");
-		assert.equal(parseBuildPlacement("NEW"), "new");
-		assert.equal(parseBuildPlacement("--new"), "new");
+describe("parseBuildOptions", () => {
+	it("executes one task here by default", () => {
+		assert.deepEqual(options(""), { scope: "one" });
 	});
-});
-
-describe("parseGoalMode", () => {
-	it("runs remaining tasks in this session by default", () => {
-		assert.equal(parseGoalMode(""), "all-here");
-		assert.equal(parseGoalMode("  "), "all-here");
-		assert.equal(parseGoalMode("unknown"), "all-here");
+	it("parses all-task execution", () => {
+		assert.deepEqual(options("all"), { scope: "all" });
+		assert.deepEqual(options("--all"), { scope: "all" });
 	});
-
-	it("accepts new and continue aliases", () => {
-		assert.equal(parseGoalMode("new"), "all-new");
-		assert.equal(parseGoalMode(" --new extra"), "all-new");
-		assert.equal(parseGoalMode("NEW"), "all-new");
-		assert.equal(parseGoalMode("continue"), "chain-here");
-		assert.equal(parseGoalMode("--continue"), "chain-here");
+	it("rejects removed placement and approval flags", () => {
+		for (const input of ["new", "fresh", "all new", "--approval"]) {
+			const result = parseBuildOptions(input);
+			assert.equal(result.ok, false);
+			if (result.ok) throw new Error("Expected removed build option to fail");
+			assert.match(result.error, /^Removed\./);
+		}
+	});
+	it("rejects unknown and duplicate options", () => {
+		assert.deepEqual(parseBuildOptions("banana"), { ok: false, error: "Unknown build option: banana" });
+		assert.equal(parseBuildOptions("all --all").ok, false);
+		assert.equal(parseBuildOptions("continue").ok, false);
 	});
 });

package/extensions/build-session.ts

@@ -1,15 +1,30 @@
-export type BuildPlacement = "here" | "new";
-export type GoalMode = "all-here" | "all-new" | "chain-here";
+export type BuildScope = "one" | "all";
 
-export function parseBuildPlacement(args: string): BuildPlacement {
-	const token = args.trim().split(/\s+/)[0]?.toLowerCase() ?? "";
-	if (token === "new" || token === "--new") return "new";
-	return "here";
+export interface BuildOptions {
+	scope: BuildScope;
 }
 
-export function parseGoalMode(args: string): GoalMode {
-	const token = args.trim().split(/\s+/)[0]?.toLowerCase() ?? "";
-	if (token === "new" || token === "--new") return "all-new";
-	if (token === "continue" || token === "--continue") return "chain-here";
-	return "all-here";
+export type BuildParseResult = { ok: true; options: BuildOptions } | { ok: false; error: string };
+
+const REMOVED = new Map<string, string>([
+	["new", "Removed. After /plan approve or a finished task, choose a new session. /build runs the next task here."],
+	["--new", "Removed. After /plan approve or a finished task, choose a new session. /build runs the next task here."],
+	["fresh", "Removed. After /plan approve, choose fresh to start a clean session."],
+	["--fresh", "Removed. After /plan approve, choose fresh to start a clean session."],
+	["approval", "Removed. Use /build for one task or /build all for the rest."],
+	["--approval", "Removed. Use /build for one task or /build all for the rest."],
+]);
+
+export function parseBuildOptions(args: string): BuildParseResult {
+	const tokens = args.trim().split(/\s+/).map((token) => token.toLowerCase()).filter(Boolean);
+	if (tokens.length === 0) return { ok: true, options: { scope: "one" } };
+	for (const token of tokens) {
+		const removed = REMOVED.get(token);
+		if (removed) return { ok: false, error: removed };
+	}
+	const normalized = tokens.map((token) => token.replace(/^--/, ""));
+	const unknown = normalized.find((token) => token !== "all");
+	if (unknown) return { ok: false, error: `Unknown build option: ${tokens[normalized.indexOf(unknown)]}` };
+	if (new Set(normalized).size !== tokens.length) return { ok: false, error: "Duplicate build options are not allowed." };
+	return { ok: true, options: { scope: "all" } };
 }

package/extensions/command-surface.test.ts

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { describe, it } from "node:test";
+
+describe("public command surface", () => {
+	it("registers only plan, build, and tasks", async () => {
+		const source = await readFile(new URL("./index.ts", import.meta.url), "utf8");
+		const commands = [...source.matchAll(/registerCommand\("([^"]+)"/g)].map((match) => match[1]);
+		assert.deepEqual(commands, ["plan", "build", "tasks"]);
+		assert.match(source, /planSubcommands = \["approve", "reject", "request"\]/);
+		assert.match(source, /value: "all"/);
+		assert.match(source, /value: "rework"/);
+		assert.doesNotMatch(source, /planSubcommands = \[[^\]]*review/);
+	});
+});

package/extensions/config.ts

@@ -1,49 +1,21 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { globalConfigPath, projectConfigPath } from "./paths.ts";
-import { DEFAULT_CONFIG, type PlanTaskConfig } from "./types.ts";
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
+import { DEFAULT_CONFIG, type ExecutionMode, type PlanTaskConfig } from "./types.ts";
+import { filterPlanTools, isAllowedPlanTool, PLAN_TOOL_ALLOWLIST } from "./tool-policy.ts";
+export { filterPlanTools, isAllowedPlanTool, PLAN_TOOL_ALLOWLIST };
+function isRecord(value: unknown): value is Record<string, unknown> { return typeof value === "object" && value !== null && !Array.isArray(value); }
 function parseConfig(raw: string): Partial<PlanTaskConfig> {
-	const parsed: unknown = JSON.parse(raw);
-	if (!isRecord(parsed)) return {};
+	const parsed: unknown = JSON.parse(raw); if (!isRecord(parsed)) return {};
 	const next: Partial<PlanTaskConfig> = {};
-	if (Array.isArray(parsed.planTools)) {
-		next.planTools = parsed.planTools.filter(
-			(item): item is string => typeof item === "string" && item.trim().length > 0,
-		);
-	}
+	if (Array.isArray(parsed.planTools)) next.planTools = filterPlanTools(parsed.planTools.filter((x): x is string => typeof x === "string" && x.trim().length > 0));
+	if (parsed.executionMode === "automatic" || parsed.executionMode === "external") next.executionMode = parsed.executionMode as ExecutionMode;
 	return next;
 }
-
-async function readConfigFile(path: string): Promise<Partial<PlanTaskConfig>> {
-	try {
-		return parseConfig(await readFile(path, "utf8"));
-	} catch {
-		return {};
-	}
-}
-
-export async function ensureDefaultGlobalConfig(): Promise<void> {
-	const path = globalConfigPath();
-	try {
-		await readFile(path, "utf8");
-	} catch {
-		await mkdir(dirname(path), { recursive: true });
-		await writeFile(path, `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`, "utf8");
-	}
-}
-
+async function readConfigFile(path: string): Promise<Partial<PlanTaskConfig>> { try { return parseConfig(await readFile(path, "utf8")); } catch { return {}; } }
+export async function ensureDefaultGlobalConfig(): Promise<void> { const path = globalConfigPath(); try { await readFile(path, "utf8"); } catch { await mkdir(dirname(path), { recursive: true }); await writeFile(path, `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`, "utf8"); } }
 export async function loadConfig(cwd: string): Promise<PlanTaskConfig> {
-	const globalConfig = await readConfigFile(globalConfigPath());
-	const projectConfig = await readConfigFile(projectConfigPath(cwd));
-	return {
-		planTools:
-			projectConfig.planTools ??
-			globalConfig.planTools ??
-			DEFAULT_CONFIG.planTools,
-	};
+	const global = await readConfigFile(globalConfigPath()), project = await readConfigFile(projectConfigPath(cwd));
+	const tools = project.planTools ?? global.planTools; const filtered = tools ? filterPlanTools(tools) : [];
+	return { ...DEFAULT_CONFIG, ...global, ...project, planTools: filtered.length ? filtered : [...DEFAULT_CONFIG.planTools] };
 }

package/extensions/files.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { markTaskDoneInMarkdown, parseTaskMarkdown } from "./parse.ts";
+import { hasPendingTasks, markTaskDoneInMarkdown, markTaskPendingInMarkdown, parseTaskMarkdown } from "./parse.ts";
 
 const SAMPLE = `# Tasks
 
@@ -45,6 +45,22 @@ describe("parseTaskMarkdown", () => {
 	});
 });
 
+
+describe("task completion boundaries", () => {
+	it("checks only the top-level task checklist", () => {
+		const next = markTaskDoneInMarkdown(SAMPLE, 1);
+		assert.match(next, /- \[x\] 1\. Add login API/);
+		assert.match(next, /- \[ \] Returns 200/);
+	});
+
+	it("does not treat acceptance criteria as pending top-level tasks", () => {
+		const complete = SAMPLE
+			.replace("- [ ] 1. Add login API", "- [x] 1. Add login API")
+			.replace("- [ ] 2. Add login UI", "- [x] 2. Add login UI");
+		assert.equal(hasPendingTasks(complete), false);
+	});
+});
+
 describe("markTaskDoneInMarkdown", () => {
 	it("checks the matching numbered item only", () => {
 		const next = markTaskDoneInMarkdown(SAMPLE, 2);
@@ -56,4 +72,8 @@ describe("markTaskDoneInMarkdown", () => {
 	it("is a no-op when the item is already done", () => {
 		assert.equal(markTaskDoneInMarkdown(SAMPLE, 3), SAMPLE);
 	});
+	it("reopens a completed numbered item", () => {
+		const done = markTaskDoneInMarkdown(SAMPLE, 1);
+		assert.match(markTaskPendingInMarkdown(done, 1), /- \[ \] 1\. Add login API/);
+	});
 });

package/extensions/files.ts

@@ -1,9 +1,9 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { planDir, planFilePath, taskFilePath } from "./paths.ts";
-import { markTaskDoneInMarkdown, parseTaskMarkdown } from "./parse.ts";
+import { mkdir, readFile } from "node:fs/promises";
+import { planDir, taskFilePath } from "./paths.ts";
+import { parseTaskMarkdown } from "./parse.ts";
 import type { TaskFile, TaskItem } from "./types.ts";
 
-export { markTaskDoneInMarkdown, parseTaskMarkdown } from "./parse.ts";
+export { markTaskDoneInMarkdown, markTaskPendingInMarkdown, markTasksPendingFromMarkdown, parseTaskMarkdown, hasPendingTasks } from "./parse.ts";
 
 export async function ensurePlanDir(cwd: string): Promise<void> {
 	await mkdir(planDir(cwd), { recursive: true });
@@ -12,36 +12,20 @@ export async function ensurePlanDir(cwd: string): Promise<void> {
 export async function readOptionalFile(path: string): Promise<string | undefined> {
 	try {
 		return await readFile(path, "utf8");
-	} catch {
-		return undefined;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw error;
 	}
 }
 
 export async function loadTaskFile(cwd: string): Promise<TaskFile | undefined> {
 	const raw = await readOptionalFile(taskFilePath(cwd));
 	if (raw === undefined) return undefined;
-	return { raw, tasks: parseTaskMarkdown(raw) };
-}
-
-export async function markTaskComplete(cwd: string, id: number): Promise<TaskFile | undefined> {
-	const current = await loadTaskFile(cwd);
-	if (!current) return undefined;
-	const nextRaw = markTaskDoneInMarkdown(current.raw, id);
-	if (nextRaw !== current.raw) {
-		await writeFile(taskFilePath(cwd), nextRaw, "utf8");
-	}
-	const planRaw = await readOptionalFile(planFilePath(cwd));
-	if (planRaw !== undefined) {
-		const nextPlan = markTaskDoneInMarkdown(planRaw, id);
-		if (nextPlan !== planRaw) {
-			await writeFile(planFilePath(cwd), nextPlan, "utf8");
-		}
+	try {
+		return { raw, tasks: parseTaskMarkdown(raw) };
+	} catch (error) {
+		throw new Error(`Invalid ${taskFilePath(cwd)}: ${String(error)}`, { cause: error });
 	}
-	return { raw: nextRaw, tasks: parseTaskMarkdown(nextRaw) };
-}
-
-export function nextPendingTask(tasks: TaskItem[]): TaskItem | undefined {
-	return tasks.find((task) => !task.done);
 }
 
 export function formatProgress(tasks: TaskItem[]): string {

package/extensions/framing.test.ts

@@ -77,6 +77,7 @@ describe("nextInjection", () => {
 		assert.equal(nextInjection("build", framed, 1, "1:1:0"), undefined);
 		assert.equal(nextInjection("build", framed, 1, "1:1:1"), "build-status");
 		assert.equal(nextInjection("build", framed, 2, "2:1:1"), "build-framing");
+		assert.equal(nextInjection("build", framed, 1, "1:1:0", "changed-plan"), "build-framing");
 	});
 
 	it("injects nothing while idle", () => {

package/extensions/framing.ts

@@ -15,6 +15,7 @@ export interface FramingState {
 	planFramingDelivered: boolean;
 	framedTaskId?: number;
 	lastStatusKey?: string;
+	planKey?: string;
 }
 
 export const INITIAL_FRAMING_STATE: FramingState = {
@@ -55,10 +56,11 @@ export function nextInjection(
 	state: FramingState,
 	currentTaskId?: number,
 	statusKey?: string,
+	planKey?: string,
 ): InjectionKind | undefined {
 	if (mode === "plan") return state.planFramingDelivered ? undefined : "plan-framing";
 	if (mode !== "build" || currentTaskId === undefined) return undefined;
-	if (state.framedTaskId !== currentTaskId) return "build-framing";
+	if (state.framedTaskId !== currentTaskId || state.planKey !== planKey) return "build-framing";
 	if (statusKey !== undefined && statusKey !== state.lastStatusKey) return "build-status";
 	return undefined;
 }
@@ -68,12 +70,13 @@ export function rememberInjection(
 	kind: InjectionKind,
 	taskId?: number,
 	statusKey?: string,
+	planKey?: string,
 ): FramingState {
 	if (kind === "plan-framing") {
 		return { ...state, planFramingDelivered: true };
 	}
 	if (kind === "build-framing") {
-		return { ...state, framedTaskId: taskId, lastStatusKey: statusKey };
+		return { ...state, framedTaskId: taskId, lastStatusKey: statusKey, planKey };
 	}
 	return { ...state, lastStatusKey: statusKey };
 }

package/extensions/history.test.ts

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { listPlanSnapshots } from "./history.ts";
+import { historyDir } from "./paths.ts";
+
+async function tempProject<T>(run: (cwd: string) => Promise<T>): Promise<T> {
+	const cwd = await mkdtemp(join(tmpdir(), "pi-plan-task-history-"));
+	try { return await run(cwd); } finally { await rm(cwd, { recursive: true, force: true }); }
+}
+
+describe("plan history", () => {
+	it("sorts numerically and skips damaged snapshots", async () => tempProject(async (cwd) => {
+		const dir = historyDir(cwd);
+		await mkdir(dir, { recursive: true });
+		await writeFile(join(dir, "snapshot-1000.json"), JSON.stringify({ version: 1000, createdAt: "later", plan: "p1000", task: "t" }), "utf8");
+		await writeFile(join(dir, "snapshot-999.json"), JSON.stringify({ version: 999, createdAt: "earlier", plan: "p999", task: "t" }), "utf8");
+		await writeFile(join(dir, "snapshot-1001.json"), "not-json", "utf8");
+		const snapshots = await listPlanSnapshots(cwd);
+		assert.deepEqual(snapshots.map((item) => item.version), [999, 1000]);
+	}));
+});

package/extensions/history.ts

@@ -0,0 +1,42 @@
+import { mkdir, readdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { historyDir } from "./paths.ts";
+
+export interface PlanSnapshot { version: number; createdAt: string; plan: string; task: string; }
+const SNAPSHOT_NAME = /^snapshot-(\d+)\.json$/;
+
+export async function savePlanSnapshot(cwd: string, plan: string, task: string): Promise<PlanSnapshot> {
+	const dir = historyDir(cwd);
+	await mkdir(dir, { recursive: true });
+	const versions = (await readdir(dir)).flatMap((name) => { const match = name.match(SNAPSHOT_NAME); return match ? [Number(match[1])] : []; });
+	const version = Math.max(0, ...versions) + 1;
+	const snapshot: PlanSnapshot = { version, createdAt: new Date().toISOString(), plan, task };
+	const path = join(dir, `snapshot-${String(version).padStart(3, "0")}.json`);
+	const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+	await writeFile(temporary, `${JSON.stringify(snapshot, null, 2)}\n`, "utf8");
+	await rename(temporary, path);
+	return snapshot;
+}
+
+export async function listPlanSnapshots(cwd: string): Promise<PlanSnapshot[]> {
+	const dir = historyDir(cwd);
+	try {
+		const files = (await readdir(dir))
+			.flatMap((name) => { const match = name.match(SNAPSHOT_NAME); return match ? [{ name, version: Number(match[1]) }] : []; })
+			.sort((a, b) => a.version - b.version);
+		const snapshots: PlanSnapshot[] = [];
+		const errors: string[] = [];
+		for (const file of files) {
+			try {
+				const value = JSON.parse(await readFile(join(dir, file.name), "utf8")) as PlanSnapshot;
+				if (value.version !== file.version || typeof value.createdAt !== "string" || typeof value.plan !== "string" || typeof value.task !== "string") throw new Error("invalid snapshot shape");
+				snapshots.push(value);
+			} catch (error) { errors.push(`${file.name}: ${String(error)}`); }
+		}
+		if (errors.length) process.emitWarning(`Skipped invalid plan snapshots: ${errors.join("; ")}`);
+		return snapshots;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+		throw error;
+	}
+}