@andares/pi-toolkits 0.9.8 → 0.11.0

package/src/features/init/apply.test.ts

@@ -0,0 +1,264 @@
+import { describe, expect, it } from "vitest";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { applyPlan, rewriteText, stateToToml } from "./apply.js";
+import { parseState } from "./detect.js";
+import { detect } from "./detect.js";
+import { buildPlan } from "./plan.js";
+import { installedProject, project, remove } from "./test-helpers.js";
+import type { Plan } from "./types.js";
+
+const ORIGINAL_PLAN = "# 计划\n\n## 路线\n\n- M1 未完成\n";
+const LEGACY: Record<string, string> = {
+	"AGENTS.md": [
+		"# demo — 项目指南",
+		"",
+		"细节记忆放在 `memory/`。",
+		"",
+		"## 8. 问题清单",
+		"",
+		"已迁至 `memory/PLAN.md` §5。",
+		"",
+	].join("\n"),
+	"memory/PLAN.md": ORIGINAL_PLAN,
+	"memory/FINISHED.md": "# 已完成\n\n## 摘要\n\n- M0：见 `implementations/2026-01-01_a.md`\n",
+	"memory/ARCHITECTURE.md": "# 架构\n\n## 分层\n\n- 见 `memory/DESIGN.md`\n",
+	"memory/DESIGN.md": "# 视觉\n",
+	"implementations/2026-01-01_a.md": "# a\n\n见 `memory/ARCHITECTURE.md`。\n",
+	"specs/a.md": "# a\n\n证据：`implementations/2026-01-01_a.md`。\n",
+	"todos/2026-01-02-x.md": "# 原始需求\n\n做点事。\n",
+	"src/a.ts": "// 见 `memory/DESIGN.md`\n",
+};
+
+function planFor(root: string): Plan {
+	return buildPlan(detect(root), {
+		toolVersion: "test",
+		now: new Date("2026-10-26T10:00:00+08:00"),
+	});
+}
+
+describe("rewriteText", () => {
+	const pairs = [
+		{ from: "memory/PLAN.md", to: "specs/PLAN.md" },
+		{ from: "memory/", to: ".agents/memory/" },
+	];
+
+	it("applies the longest prefix first", () => {
+		const result = rewriteText("see `memory/PLAN.md` and `memory/X.md`", pairs);
+		expect(result.text).toBe("see `specs/PLAN.md` and `.agents/memory/X.md`");
+		expect(result.hits).toBe(2);
+	});
+
+	it("leaves already-migrated paths and path tails alone", () => {
+		const result = rewriteText("`.agents/memory/X.md` ~/.pi/agent/memory/y", pairs);
+		expect(result.text).toBe("`.agents/memory/X.md` ~/.pi/agent/memory/y");
+		expect(result.hits).toBe(0);
+	});
+});
+
+describe("applyPlan", () => {
+	it("moves the legacy layout, rewrites references and keeps the originals", () => {
+		const root = project(LEGACY);
+		try {
+			const plan = planFor(root);
+			const expectedHits = plan.facts.refs.hits;
+			const applied = applyPlan(plan, { now: new Date("2026-10-26T10:00:00+08:00") });
+
+			expect(existsSync(join(root, "memory"))).toBe(false);
+			expect(existsSync(join(root, "implementations"))).toBe(false);
+			expect(existsSync(join(root, ".agents/memory/FINISHED.md"))).toBe(true);
+			expect(existsSync(join(root, ".agents/implementations/2026-01-01_a.md"))).toBe(true);
+
+			// The plan file moves byte-identically; the model shapes it afterwards.
+			expect(readFileSync(join(root, "specs/PLAN.md"), "utf8")).toBe(ORIGINAL_PLAN);
+
+			// References are rewritten in prose and code alike.
+			expect(readFileSync(join(root, "src/a.ts"), "utf8")).toContain(".agents/memory/DESIGN.md");
+			expect(readFileSync(join(root, "specs/a.md"), "utf8")).toContain(
+				".agents/implementations/2026-01-01_a.md",
+			);
+			const agents = readFileSync(join(root, "AGENTS.md"), "utf8");
+			expect(agents).toContain(".agents/memory/");
+			expect(agents).toContain("specs/PLAN.md");
+
+			// Snapshot keeps the pre-move bytes (and therefore the old paths).
+			expect(applied.snapshot?.dir).toMatch(/^\.agents\/framework\/snapshots\//);
+			const snapshotFile = join(root, applied.snapshot?.dir ?? "", "files/src/a.ts");
+			expect(readFileSync(snapshotFile, "utf8")).toContain("memory/DESIGN.md");
+			expect(existsSync(join(root, applied.snapshot?.dir ?? "", "manifest.json"))).toBe(true);
+
+			// Counts reconcile with the survey.
+			expect(applied.rewrites?.hits).toBe(expectedHits);
+
+			// State, work order and coverage worklist exist and are readable.
+			expect(applied.statePath).toBe(".agents/framework/state.toml");
+			const state = parseState(readFileSync(join(root, ".agents/framework/state.toml"), "utf8"));
+			expect(state.version).toBe(1);
+			expect(state.migrations.length).toBeGreaterThan(0);
+			expect(state.lang).toBe("zh");
+			expect(applied.planPath).toMatch(/^\.agents\/framework\/plans\/plan-.*\.json$/);
+			const order = JSON.parse(readFileSync(join(root, applied.planPath ?? ""), "utf8")) as {
+				tasks: Array<{ id: string }>;
+			};
+			expect(order.tasks.map((task) => task.id)).toContain("triage-todos");
+			expect(applied.created).toContain(".agents/memory/README.md");
+
+			expect(plan.artifacts.coverage).toMatch(/^\.agents\/framework\/reports\/coverage-.*\.md$/);
+			const coverage = readFileSync(join(root, plan.artifacts.coverage ?? ""), "utf8");
+			expect(coverage).toContain("OPEN");
+			expect(coverage).toContain("AGENTS.md");
+		} finally {
+			remove(root);
+		}
+	});
+
+	it("is safe to run twice", () => {
+		const root = project(LEGACY);
+		try {
+			const plan = planFor(root);
+			applyPlan(plan, { now: new Date("2026-10-26T10:00:00+08:00") });
+			const second = applyPlan(plan, { now: new Date("2026-10-26T10:05:00+08:00") });
+			expect(second.moved).toHaveLength(0);
+			expect(second.rewrites?.hits).toBe(0);
+			expect(second.skipped.length).toBeGreaterThan(0);
+			expect(existsSync(join(root, ".agents/memory/FINISHED.md"))).toBe(true);
+			expect(existsSync(join(root, "memory"))).toBe(false);
+		} finally {
+			remove(root);
+		}
+	});
+
+	it("writes nothing on a dry run", () => {
+		const root = project(LEGACY);
+		try {
+			const plan = planFor(root);
+			applyPlan(plan, {
+				dryRun: true,
+				now: new Date("2026-10-26T10:00:00+08:00"),
+			});
+			expect(existsSync(join(root, "memory"))).toBe(true);
+			expect(existsSync(join(root, ".agents"))).toBe(false);
+		} finally {
+			remove(root);
+		}
+	});
+
+	it("does not merge two copies of a directory on its own", () => {
+		const root = installedProject({
+			"memory/FINISHED.md": "# old finished\n",
+		});
+		try {
+			const plan = planFor(root);
+			expect(plan.mode).toBe("reconcile");
+			applyPlan(plan, { now: new Date("2026-10-26T10:00:00+08:00") });
+			expect(existsSync(join(root, "memory/FINISHED.md"))).toBe(true);
+			expect(readFileSync(join(root, ".agents/memory/FINISHED.md"), "utf8")).toContain("Summary");
+		} finally {
+			remove(root);
+		}
+	});
+
+	it("round-trips state through TOML", () => {
+		const root = installedProject();
+		try {
+			const plan = planFor(root);
+			const state = {
+				version: 1,
+				tool: "9.9.9",
+				created: "2026-01-01T00:00:00+08:00",
+				updated: "2026-01-02T00:00:00+08:00",
+				profile: "core" as const,
+				modules: ["design"],
+				lang: "zh" as const,
+				roots: [
+					{
+						label: "api",
+						path: "../api",
+						absolute: "/tmp/api",
+						role: "backend",
+						agentsMd: "scope-card" as const,
+						source: "add-dir" as const,
+						exists: true,
+						lastSeen: "2026-01-02T00:00:00+08:00",
+					},
+				],
+				managed: [],
+				migrations: [{ at: "2026-01-02T00:00:00+08:00", to: "1", notes: "adopt" }],
+			};
+			const parsed = parseState(stateToToml(state));
+			expect(parsed.roots[0]).toMatchObject({ label: "api", agentsMd: "scope-card" });
+			expect(parsed.migrations[0].notes).toBe("adopt");
+			expect(parsed.budgets).toBeUndefined();
+			void plan;
+		} finally {
+			remove(root);
+		}
+	});
+});
+
+
+describe("review regressions", () => {
+	it("preserves relative prefixes while rewriting", () => {
+		const result = rewriteText("see `../memory/A.md` and `./implementations/B.md`", [
+			{ from: "memory/", to: ".agents/memory/" },
+			{ from: "implementations/", to: ".agents/implementations/" },
+		]);
+		expect(result.text).toBe(
+			"see `../.agents/memory/A.md` and `./.agents/implementations/B.md`",
+		);
+		expect(result.hits).toBe(2);
+	});
+
+	it("records managed hashes after the reference rewrite", () => {
+		const root = project(LEGACY);
+		try {
+			applyPlan(planFor(root), { now: new Date("2026-10-26T10:00:00+08:00") });
+			const state = parseState(readFileSync(join(root, ".agents/framework/state.toml"), "utf8"));
+			for (const entry of state.managed) {
+				const digest = createHash("sha256")
+					.update(readFileSync(join(root, entry.path)))
+					.digest("hex");
+				expect(entry.sha256, entry.path).toBe(digest);
+			}
+		} finally {
+			remove(root);
+		}
+	});
+
+	it("moves a root-level PLAN.md into the plan home", () => {
+		const root = project({
+			"AGENTS.md": "# demo\n\nSee `PLAN.md`.\n",
+			"PLAN.md": "# Plan\n\n## Route\n\n- open item\n",
+		});
+		try {
+			const plan = planFor(root);
+			const move = plan.actions.find((action) => action.kind === "move-file");
+			expect(move && move.kind === "move-file" ? move.from : "").toBe("PLAN.md");
+			expect(plan.tasks.some((task) => task.id === "edit-plan")).toBe(true);
+			const applied = applyPlan(plan, { now: new Date("2026-10-26T10:00:00+08:00") });
+			expect(existsSync(join(root, "PLAN.md"))).toBe(false);
+			expect(readFileSync(join(root, "specs/PLAN.md"), "utf8")).toContain("open item");
+			// The moved source must be recoverable, not just the destination.
+			expect(
+				existsSync(join(root, applied.snapshot?.dir ?? "", "files/PLAN.md")),
+			).toBe(true);
+		} finally {
+			remove(root);
+		}
+	});
+});
+
+
+it("does not corrupt non-UTF-8 files during reference rewriting", () => {
+	const root = project(LEGACY);
+	try {
+		const latin = Buffer.from("// see `memory/DESIGN.md` — caf\xe9\n", "latin1");
+		writeFileSync(join(root, "src/latin1.ts"), latin);
+		applyPlan(planFor(root), { now: new Date("2026-10-26T10:00:00+08:00") });
+		expect(readFileSync(join(root, "src/latin1.ts"))).toEqual(latin);
+		expect(readFileSync(join(root, "src/a.ts"), "utf8")).toContain(".agents/memory/DESIGN.md");
+	} finally {
+		remove(root);
+	}
+});