diffing 0.16.1 → 0.18.0

package/dist/{setup-BnS_rSxK.mjs → setup-BwWZ9Fzq.mjs}

@@ -1,6 +1,6 @@
 import { S as isGitRepo, h as getRepoRoot } from "./git-BGj31GX-.mjs";
 import { a as markSetupCompleted, i as loadSettings, n as formatModeLabel, o as resetSetupCompleted, r as isSetupCompleted, s as saveSettings, t as ensureConfigDir } from "./settings-DkPDB_hS.mjs";
-import { n as completionFor } from "./completions-7YSX1neu.mjs";
+import { n as completionFor } from "./completions-2aHVTmiJ.mjs";
 import { a as hintLine, c as stepHeader, i as dim, l as tone, n as box, o as isColorEnabled, r as copyBlock, s as rule, t as bold } from "./terminal-BroplOnw.mjs";
 import { n as runDoctor, t as formatDoctorReport } from "./doctor-BxTaLqAF.mjs";
 import { t as DOCS_GETTING_STARTED_URL } from "./setup-first-run-i1o7DBki.mjs";

package/extensions/pi/index.ts

@@ -3,7 +3,8 @@
  *
  * Bridges the local-first diffing review loop into pi:
  *  - Structured LLM tools mirroring the diffing MCP surface (status, review
- *    start, comments, reply/resolve, plan loop, progress, sessions, GH PR).
+ *    start, comments, reply/resolve, plan loop, mockup loop, progress,
+ *    sessions, GH PR).
  *  - `/diffing` command to open/reuse the review UI for the current repo.
  *  - Footer status showing the active review session.
  *  - Skill self-heal: keeps `~/.agents/skills/diffing*` as symlinks to the
@@ -20,12 +21,14 @@ import { spawn } from "node:child_process";
 import {
 	existsSync,
 	lstatSync,
+	mkdtempSync,
 	readFileSync,
 	realpathSync,
 	rmSync,
 	symlinkSync,
+	writeFileSync,
 } from "node:fs";
-import { homedir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { StringEnum } from "@earendil-works/pi-ai";
@@ -42,9 +45,11 @@ import { Type } from "typebox";
 const SKILL_NAMES = [
 	"diffing",
 	"diffing-finish-review",
+	"diffing-mockup-review",
 	"diffing-plan-review",
 	"diffing-pr-address",
 	"diffing-pr-read",
+	"diffing-release",
 	"diffing-review",
 	"diffing-start-review",
 ] as const;
@@ -243,12 +248,12 @@ function findCanonicalRoot(cwd: string): string | null {
 }
 
 /**
- * Keep the 7 `~/.agents/skills/diffing*` entries as symlinks to the canonical
+ * Keep the `~/.agents/skills/diffing*` entries as symlinks to the canonical
  * checkout's `.agents/skills`. pi dedupes skills by canonical realpath, so
  * symlinked home entries merge silently with the repo's project skills and no
  * `[Skill conflicts]` banner appears. Repairs stale real copies left behind by
- * `diffing setup skills` / `npx skills add --copy`. Only touches the 7 known
- * names; never deletes anything else.
+ * `diffing setup skills` / `npx skills add --copy`. Only touches the known
+ * names in SKILL_NAMES; never deletes anything else.
  */
 function selfHealSkillLinks(canonical: string): void {
 	const homeSkills = join(homedir(), ".agents", "skills");
@@ -815,6 +820,449 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	pi.registerTool({
+		name: "diffing_mockup_submit",
+		label: "Diffing Mockup Submit",
+		description:
+			"Submit HTML mockup screen(s) for visual review. Pass a single html body, a file/dir path, or an inline screens array [{id, html}]. Share the URL and park unless asked to wait. Resubmit with mockupId to bump the version and reset the verdict.",
+		parameters: Type.Object({
+			html: Type.Optional(
+				Type.String({ description: "Single-screen HTML body." }),
+			),
+			file: Type.Optional(
+				Type.String({
+					description:
+						"HTML file or directory of screens (never inside the consumer git tree).",
+				}),
+			),
+			screens: Type.Optional(
+				Type.Array(
+					Type.Object({
+						id: Type.String({ description: "Screen id (slugified)." }),
+						html: Type.String({ description: "Screen HTML body." }),
+					}),
+					{
+						description:
+							"Multi-screen: array of {id, html}. Mutually exclusive with html/file.",
+					},
+				),
+			),
+			title: Type.Optional(Type.String()),
+			mockupId: Type.Optional(
+				Type.String({ description: "Resubmit this id." }),
+			),
+			model: Type.Optional(Type.String()),
+			source: Type.Optional(Type.String()),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const args = ["mockup", "submit"];
+			let stdin: string | undefined;
+			let cleanup: (() => void) | undefined;
+			const screens = Array.isArray(params.screens) ? params.screens : [];
+			if (screens.length > 0) {
+				const dir = mkdtempSync(join(tmpdir(), "diffing-mockup-"));
+				cleanup = () => {
+					try {
+						rmSync(dir, { recursive: true, force: true });
+					} catch {
+						// best-effort cleanup of the staging dir
+					}
+				};
+				for (let i = 0; i < screens.length; i++) {
+					const id =
+						String(screens[i]?.id ?? "")
+							.trim()
+							.toLowerCase()
+							.replace(/\.html?$/i, "")
+							.replace(/[^a-z0-9_-]+/g, "-")
+							.replace(/^-+|-+$/g, "") || `screen-${i + 1}`;
+					const file = join(dir, `${id}.html`);
+					writeFileSync(file, String(screens[i]?.html ?? ""), "utf-8");
+					args.push("--screen", `${id}=${file}`);
+				}
+			} else if (params.file) {
+				args.push(params.file);
+			} else if (params.html !== undefined) {
+				args.push("-");
+				stdin = params.html;
+			} else {
+				return textResult(
+					"Provide one of html (single screen), file (path/dir), or screens ([{id, html}]).",
+					{ submitted: false },
+				);
+			}
+			if (params.title) args.push("--title", params.title);
+			if (params.mockupId) args.push("--id", params.mockupId);
+			if (params.model) args.push("--model", params.model);
+			if (params.source) args.push("--source", params.source);
+			try {
+				const result = await runDiffing(args, ctx.cwd, { stdin });
+				const stdout = result.stdout.trim();
+				const stderr = result.stderr.trim();
+				if (result.exitCode !== 0) {
+					return textResult(describe(result, "diffing mockup submit"), {
+						submitted: false,
+						exitCode: result.exitCode,
+						stderr,
+					});
+				}
+				return textResult(`${stdout}\n${stderr}`.trim() || "(submitted)", {
+					submitted: true,
+					mockupId: stdout || undefined,
+					url: stderr || undefined,
+				});
+			} finally {
+				cleanup?.();
+			}
+		},
+	});
+
+	pi.registerTool({
+		name: "diffing_mockup_await",
+		label: "Diffing Mockup Await",
+		description:
+			"Sync wait for a mockup verdict. Prefer park after submit unless asked to wait.",
+		parameters: Type.Object({
+			timeout: Type.Optional(
+				Type.Number({ description: "Seconds to wait. Default 25." }),
+			),
+		}),
+		async execute(_id, params, signal, _onUpdate, ctx) {
+			const timeout = params.timeout ?? 25;
+			const result = await runDiffing(
+				["mockup", "await", "-t", String(timeout)],
+				ctx.cwd,
+				{ signal },
+			);
+			if (result.exitCode === 2) {
+				return textResult(
+					`No mockup verdict within ${timeout}s (park). Share the mockup URL and end your turn.`,
+					{ parked: true, exitCode: result.exitCode },
+				);
+			}
+			return textResult(describe(result, "diffing mockup await"), {
+				parked: false,
+				exitCode: result.exitCode,
+				stderr: result.stderr.trim() || undefined,
+			});
+		},
+	});
+
+	pi.registerTool({
+		name: "diffing_mockup_reply",
+		label: "Diffing Mockup Reply",
+		description: "Reply to a mockup comment thread.",
+		parameters: Type.Object({
+			commentId: Type.String(),
+			body: Type.String(),
+			model: Type.Optional(Type.String()),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const result = await runDiffing(
+				[
+					"mockup",
+					"reply",
+					params.commentId,
+					"-",
+					"--model",
+					modelName(ctx, params.model),
+				],
+				ctx.cwd,
+				{ stdin: params.body },
+			);
+			return textResult(
+				describe(result, `diffing mockup reply ${params.commentId}`),
+				{
+					exitCode: result.exitCode,
+					stderr: result.stderr.trim() || undefined,
+				},
+			);
+		},
+	});
+
+	pi.registerTool({
+		name: "diffing_mockup_resolve",
+		label: "Diffing Mockup Resolve",
+		description: "Mark a mockup comment resolved.",
+		parameters: Type.Object({
+			commentId: Type.String(),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const result = await runDiffing(
+				["mockup", "resolve", params.commentId],
+				ctx.cwd,
+			);
+			return textResult(
+				describe(result, `diffing mockup resolve ${params.commentId}`),
+				{
+					exitCode: result.exitCode,
+					stderr: result.stderr.trim() || undefined,
+				},
+			);
+		},
+	});
+
+	pi.registerTool({
+		name: "diffing_mockup_list",
+		label: "Diffing Mockup List",
+		description:
+			"List submitted HTML mockups for this repo (id, decision, version, screen count, open comments, title).",
+		parameters: Type.Object({
+			json: Type.Optional(
+				Type.Boolean({ description: "Emit raw JSON. Default: false." }),
+			),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const args = ["mockup", "list"];
+			if (params.json) args.push("--json");
+			const result = await runDiffing(args, ctx.cwd);
+			return textResult(describe(result, "diffing mockup list"), {
+				exitCode: result.exitCode,
+				stderr: result.stderr.trim() || undefined,
+			});
+		},
+	});
+
+	pi.registerTool({
+		name: "diffing_mockup_show",
+		label: "Diffing Mockup Show",
+		description:
+			"Fetch one mockup by id (defaults to the latest), including screens and comments. Prefer diffing_mockup_inspect for bounded reads.",
+		parameters: Type.Object({
+			mockupId: Type.Optional(
+				Type.String({ description: "Mockup id. Default: latest." }),
+			),
+			version: Type.Optional(
+				Type.Number({ description: "Historical version to render." }),
+			),
+			json: Type.Optional(
+				Type.Boolean({ description: "Emit raw JSON. Default: false." }),
+			),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const args = ["mockup", "show"];
+			if (params.mockupId) args.push(params.mockupId);
+			if (params.version !== undefined)
+				args.push("--version", String(params.version));
+			if (params.json) args.push("--json");
+			const result = await runDiffing(args, ctx.cwd);
+			return textResult(describe(result, "diffing mockup show"), {
+				exitCode: result.exitCode,
+				stderr: result.stderr.trim() || undefined,
+			});
+		},
+	});
+
+	pi.registerTool({
+		name: "diffing_mockup_versions",
+		label: "Diffing Mockup Versions",
+		description: "List version snapshots for a mockup.",
+		parameters: Type.Object({
+			mockupId: Type.String({ description: "Mockup id." }),
+			json: Type.Optional(
+				Type.Boolean({ description: "Emit raw JSON. Default: false." }),
+			),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const args = ["mockup", "versions", params.mockupId];
+			if (params.json) args.push("--json");
+			const result = await runDiffing(args, ctx.cwd);
+			return textResult(describe(result, "diffing mockup versions"), {
+				exitCode: result.exitCode,
+				stderr: result.stderr.trim() || undefined,
+			});
+		},
+	});
+
+	pi.registerTool({
+		name: "diffing_mockup_inspect",
+		label: "Diffing Mockup Inspect",
+		description:
+			"Read compact, bounded mockup data without transferring screen HTML. view=summary (headline stats), comments (paged comment list), comment (one thread), screen (screen source). Filter by comment scope: status, screenId, viewport (desktop|tablet|mobile), version. context=none|anchor|source controls anchor detail. Prefer this over diffing_mockup_show.",
+		parameters: Type.Object({
+			view: StringEnum(["summary", "comments", "comment", "screen"] as const, {
+				description: "What to read. Default: summary.",
+				default: "summary",
+			}),
+			mockupId: Type.Optional(
+				Type.String({ description: "Mockup id. Default: latest." }),
+			),
+			status: Type.Optional(
+				StringEnum(["open", "resolved"] as const, {
+					description: "Filter comments by status.",
+				}),
+			),
+			screenId: Type.Optional(
+				Type.String({ description: "Filter by screen id." }),
+			),
+			viewport: Type.Optional(
+				StringEnum(["desktop", "tablet", "mobile"] as const, {
+					description: "Filter by viewport.",
+				}),
+			),
+			version: Type.Optional(
+				Type.Number({
+					description:
+						"Filter comments by the mockup version they were created on.",
+				}),
+			),
+			commentId: Type.Optional(
+				Type.String({ description: "For view=comment: the thread id." }),
+			),
+			cursor: Type.Optional(Type.Number({ description: "Pagination cursor." })),
+			limit: Type.Optional(
+				Type.Number({ description: "Max results per page." }),
+			),
+			context: Type.Optional(
+				StringEnum(["none", "anchor", "source"] as const, {
+					description:
+						"Anchor detail: none, anchor (locators), source (+contextHtml). Default: anchor.",
+					default: "anchor",
+				}),
+			),
+			pretty: Type.Optional(
+				Type.Boolean({ description: "Indent JSON output." }),
+			),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const args = ["mockup", "inspect", params.view ?? "summary"];
+			if (params.mockupId) args.push(params.mockupId);
+			if (params.status) args.push("--status", params.status);
+			if (params.screenId) args.push("--screen", params.screenId);
+			if (params.viewport) args.push("--viewport", params.viewport);
+			if (params.version !== undefined)
+				args.push("--version", String(params.version));
+			if (params.commentId) args.push("--id", params.commentId);
+			if (params.cursor !== undefined)
+				args.push("--cursor", String(params.cursor));
+			if (params.limit !== undefined)
+				args.push("--limit", String(params.limit));
+			if (params.context) args.push("--context", params.context);
+			if (params.pretty) args.push("--pretty");
+			const result = await runDiffing(args, ctx.cwd);
+			return textResult(describe(result, "diffing mockup inspect"), {
+				exitCode: result.exitCode,
+				stderr: result.stderr.trim() || undefined,
+			});
+		},
+	});
+
+	pi.registerTool({
+		name: "diffing_mockup_screen",
+		label: "Diffing Mockup Screen",
+		description:
+			"One-screen revision of an HTML mockup. action=upsert adds/replaces a screen (html or file), remove deletes a screen, patch replaces the first exact occurrence of text with replacement. Every success bumps the mockup version; pass expectedVersion to guard racing edits (409 version-mismatch, nothing applied). For multi-screen revisions, resubmit via diffing_mockup_submit with the same mockupId.",
+		parameters: Type.Object({
+			action: StringEnum(["upsert", "remove", "patch"] as const, {
+				description: "Revision op.",
+			}),
+			mockupId: Type.String({ description: "Mockup id." }),
+			screenId: Type.String({ description: "Screen id." }),
+			html: Type.Optional(
+				Type.String({
+					description: "For upsert: inline screen HTML (alternative to file).",
+				}),
+			),
+			file: Type.Optional(
+				Type.String({
+					description: "For upsert: HTML file path; '-' for stdin.",
+				}),
+			),
+			label: Type.Optional(
+				Type.String({ description: "For upsert: optional screen label." }),
+			),
+			text: Type.Optional(
+				Type.String({
+					description: "For patch: exact text to replace (first occurrence).",
+				}),
+			),
+			replacement: Type.Optional(
+				Type.String({ description: "For patch: replacement text." }),
+			),
+			expectedVersion: Type.Optional(
+				Type.Number({
+					description: "Guard: current mockup version. 409 on mismatch.",
+				}),
+			),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const args = [
+				"mockup",
+				"screen",
+				params.action,
+				params.mockupId,
+				params.screenId,
+			];
+			let stdin: string | undefined;
+			if (params.action === "upsert") {
+				if (params.file) args.push("--file", params.file);
+				else if (params.html !== undefined) {
+					args.push("--file", "-");
+					stdin = params.html;
+				}
+				if (params.label) args.push("--label", params.label);
+			} else if (params.action === "patch") {
+				if (params.text !== undefined) args.push("--text", params.text);
+				if (params.replacement !== undefined)
+					args.push("--replacement", params.replacement);
+			}
+			if (params.expectedVersion !== undefined)
+				args.push("--expected-version", String(params.expectedVersion));
+			const result = await runDiffing(args, ctx.cwd, { stdin });
+			return textResult(describe(result, "diffing mockup screen"), {
+				exitCode: result.exitCode,
+				stderr: result.stderr.trim() || undefined,
+			});
+		},
+	});
+
+	pi.registerTool({
+		name: "diffing_mockup_threads",
+		label: "Diffing Mockup Threads",
+		description:
+			"Atomic single-op mockup thread mutation: reply (agent answer), edit (comment body or a reply), delete (comment or reply), resolve, unresolve. Thread ops never bump the mockup version. For several ops, call once per op; each call is validated before apply.",
+		parameters: Type.Object({
+			action: StringEnum(
+				["reply", "edit", "delete", "resolve", "unresolve"] as const,
+				{ description: "Thread op." },
+			),
+			commentId: Type.String({ description: "Comment thread id." }),
+			replyId: Type.Optional(
+				Type.String({
+					description:
+						"For edit/delete: target a reply instead of the comment.",
+				}),
+			),
+			body: Type.Optional(
+				Type.String({ description: "For reply/edit: markdown body." }),
+			),
+			model: Type.Optional(
+				Type.String({
+					description:
+						"For reply: authoring model. Defaults to the active model.",
+				}),
+			),
+			mockupId: Type.Optional(
+				Type.String({
+					description:
+						"Owning mockup id (auto-detected from commentId when omitted).",
+				}),
+			),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const args = ["mockup", "threads", params.action, params.commentId];
+			if (params.replyId) args.push(params.replyId);
+			if (params.body !== undefined) args.push("--body", params.body);
+			if (params.model) args.push("--model", modelName(ctx, params.model));
+			if (params.mockupId) args.push("--id", params.mockupId);
+			const result = await runDiffing(args, ctx.cwd);
+			return textResult(describe(result, "diffing mockup threads"), {
+				exitCode: result.exitCode,
+				stderr: result.stderr.trim() || undefined,
+			});
+		},
+	});
+
 	pi.registerTool({
 		name: "diffing_url",
 		label: "Diffing URL",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diffing",
-  "version": "0.16.1",
+  "version": "0.18.0",
   "description": "local-first CLI for reviewing, navigating, and discussing git diffs with AI",
   "type": "module",
   "license": "MIT",
@@ -56,6 +56,7 @@
     "verify:release-bundle": "node scripts/verify-tui-bundle.mjs",
     "prepublishOnly": "pnpm run verify:release-bundle",
     "version-packages": "changeset version",
+    "release": "node scripts/release.mjs",
     "docs:dev": "pnpm --dir site dev",
     "docs:build": "pnpm --dir site build",
     "docs:preview": "pnpm --dir site preview"

package/dist/client/assets/channel-DsuXeLi4.js

@@ -1 +0,0 @@
-import{at as e,ot as t}from"./chunk-CSCIHK7Q-jYiloqyi.js";var n=(n,r)=>t.lang.round(e.parse(n)[r]);export{n as t};

package/dist/client/assets/chunk-QZHKN3VN-D5b3mBJ2.js

@@ -1 +0,0 @@
-import{h as e}from"./src-BO-qT_v_.js";var t=class{constructor(e){this.init=e,this.records=this.init()}static{e(this,`ImperativeState`)}reset(){this.records=this.init()}};export{t};

package/dist/client/assets/chunk-WU5MYG2G-C1Pa4Y04.js

@@ -1 +0,0 @@
-import{h as e,p as t}from"./src-BO-qT_v_.js";import{x as n}from"./chunk-CSCIHK7Q-jYiloqyi.js";var r=e(e=>{let{securityLevel:r}=n(),i=t(`body`);return r===`sandbox`&&(i=t((t(`#i${e}`).node()?.contentDocument??document).body)),i.select(`#${e}`)},`selectSvgElement`);export{r as t};

package/dist/client/assets/classDiagram-4FO5ZUOK-DCnVfYt-.js

@@ -1 +0,0 @@
-import{h as e}from"./src-BO-qT_v_.js";import"./chunk-CSCIHK7Q-jYiloqyi.js";import"./chunk-5ZQYHXKU-BI1cj2cZ.js";import"./chunk-O5CBEL6O-B1e1HGaX.js";import"./chunk-FMBD7UC4-DZzqIT32.js";import"./chunk-BSJP7CBP-CXXvPXhK.js";import"./chunk-L5ZTLDWV-0uuTmeZV.js";import"./chunk-ND2GUHAM-jkir4ZKE.js";import"./chunk-55IACEB6-BsXuKAKc.js";import"./chunk-2J33WTMH-Dod_VwYj.js";import"./chunk-NZK2D7GU-DMWZNibJ.js";import"./chunk-3OPIFGDE-B8HMjry-.js";import"./chunk-KSCS5N6A-krdCf8iG.js";import"./chunk-LZXEDZCA-BBfUgD06.js";import{i as t,n,r,t as i}from"./chunk-727SXJPM-yWQ27Wk0.js";var a={parser:n,get db(){return new i},renderer:r,styles:t,init:e(e=>{e.class||={},e.class.arrowMarkerAbsolute=e.arrowMarkerAbsolute},`init`)};export{a as diagram};

package/dist/client/assets/classDiagram-v2-Q7XG4LA2-BPa1Jkt-.js

@@ -1 +0,0 @@
-import{h as e}from"./src-BO-qT_v_.js";import"./chunk-CSCIHK7Q-jYiloqyi.js";import"./chunk-5ZQYHXKU-BI1cj2cZ.js";import"./chunk-O5CBEL6O-B1e1HGaX.js";import"./chunk-FMBD7UC4-DZzqIT32.js";import"./chunk-BSJP7CBP-CXXvPXhK.js";import"./chunk-L5ZTLDWV-0uuTmeZV.js";import"./chunk-ND2GUHAM-jkir4ZKE.js";import"./chunk-55IACEB6-BsXuKAKc.js";import"./chunk-2J33WTMH-Dod_VwYj.js";import"./chunk-NZK2D7GU-DMWZNibJ.js";import"./chunk-3OPIFGDE-B8HMjry-.js";import"./chunk-KSCS5N6A-krdCf8iG.js";import"./chunk-LZXEDZCA-BBfUgD06.js";import{i as t,n,r,t as i}from"./chunk-727SXJPM-yWQ27Wk0.js";var a={parser:n,get db(){return new i},renderer:r,styles:t,init:e(e=>{e.class||={},e.class.arrowMarkerAbsolute=e.arrowMarkerAbsolute},`init`)};export{a as diagram};