pi-plan-task 1.1.0 → 3.0.1

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 { buildHandoffCommand, 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", placement: "here", approval: false, continuation: false });
 	});
-});
-
-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 placement and all-task execution", () => {
+		assert.equal(options("new").placement, "new");
+		assert.equal(options("--fresh").placement, "fresh");
+		assert.deepEqual(options("all new --approval"), { scope: "all", placement: "new", approval: true, continuation: false });
 	});
-
-	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 unknown, duplicate, and conflicting options", () => {
+		assert.deepEqual(parseBuildOptions("banana"), { ok: false, error: "Unknown build option: banana" });
+		assert.equal(parseBuildOptions("new fresh").ok, false);
+		assert.equal(parseBuildOptions("all --all").ok, false);
+		assert.equal(parseBuildOptions("continue").ok, false);
+		assert.equal(parseBuildOptions("--approval").ok, false);
+	});
+	it("builds public handoff commands", () => {
+		assert.equal(buildHandoffCommand(options("new")), "/build");
+		assert.equal(buildHandoffCommand(options("all new --approval")), "/build");
+		assert.equal(buildHandoffCommand(options("all fresh --approval")), "/build all --approval");
 	});
 });

package/extensions/build-session.ts

@@ -1,15 +1,42 @@
-export type BuildPlacement = "here" | "new";
-export type GoalMode = "all-here" | "all-new" | "chain-here";
+export type BuildPlacement = "here" | "new" | "fresh";
+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;
+	placement: BuildPlacement;
+	approval: boolean;
+	continuation: boolean;
 }
 
-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 ALLOWED = new Set(["all", "--all", "new", "--new", "fresh", "--fresh", "approval", "--approval"]);
+
+export function parseBuildOptions(args: string): BuildParseResult {
+	const tokens = args.trim().split(/\s+/).map((token) => token.toLowerCase()).filter(Boolean);
+	const unknown = tokens.find((token) => !ALLOWED.has(token));
+	if (unknown) return { ok: false, error: `Unknown build option: ${unknown}` };
+	const hasNew = tokens.includes("new") || tokens.includes("--new");
+	const hasFresh = tokens.includes("fresh") || tokens.includes("--fresh");
+	if (hasNew && hasFresh) return { ok: false, error: "new and fresh cannot be combined." };
+	const unique = new Set(tokens.map((token) => token.replace(/^--/, "")));
+	if (unique.size !== tokens.length) return { ok: false, error: "Duplicate build options are not allowed." };
+	const scope: BuildScope = tokens.includes("all") || tokens.includes("--all") ? "all" : "one";
+	const approval = tokens.includes("approval") || tokens.includes("--approval");
+	if (approval && scope !== "all") return { ok: false, error: "approval requires all-task execution." };
+	return {
+		ok: true,
+		options: {
+			scope,
+			placement: hasFresh ? "fresh" : hasNew ? "new" : "here",
+			approval,
+			continuation: false,
+		},
+	};
+}
+
+export function buildHandoffCommand(options: Pick<BuildOptions, "scope" | "placement" | "approval">): string {
+	if (options.scope === "one" || options.placement === "new") return "/build";
+	const approvalFlag = options.approval ? " --approval" : "";
+	return `/build all${approvalFlag}`;
 }

package/extensions/command-surface.test.ts

@@ -0,0 +1,11 @@
+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"]);
+	});
+});

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;
+	}
+}