@posthog/wizard 2.43.0 → 2.45.0

package/dist/{wizard-tools-BcuRxp1A.js → wizard-tools-Dg8o2lcH.js}

@@ -1,41 +1,12 @@
-import { s as logToFile } from "./debug-DNEQR5DL.js";
-import { n as analytics } from "./analytics-C_9Kh6J1.js";
-import { a as coerceAuditChecks, t as AUDIT_CHECKS_FILE } from "./types-y3HkjtSq.js";
-import * as fs$1 from "fs";
+import { s as logToFile } from "./debug-DBmxx59Q.js";
+import { n as analytics } from "./analytics-DQEuL6qS.js";
+import { c as makeMutex, i as buildOrchestratorTools, l as writeJsonAtomic } from "./queue-tools-Bw-AANLM.js";
+import { a as coerceAuditChecks, t as AUDIT_CHECKS_FILE } from "./types-BRe_EzTW.js";
 import fs from "fs";
-import * as path$1 from "path";
 import path from "path";
 import { z } from "zod";
 import { unzipSync } from "fflate";
 import { randomUUID } from "crypto";
-//#region src/utils/atomic-ledger.ts
-/**
-* Small shared primitives for on-disk ledgers: an atomic JSON writer and a
-* single-chain async mutex. Used by the audit tools and by the orchestrator
-* queue. Lifted here so both share one implementation.
-*/
-/**
-* Atomically write JSON: write to a `.tmp` file then rename over the target. The
-* rename bumps the file's mtime in one step, which is what a file watcher polls.
-*/
-function writeJsonAtomic(targetPath, data) {
-	const tmpPath = `${targetPath}.tmp`;
-	fs$1.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf8");
-	fs$1.renameSync(tmpPath, targetPath);
-}
-/**
-* A single async mutex. Serializes read-modify-write cycles so concurrent callers
-* (parallel task agents, audit tool calls) never interleave a mutation.
-*/
-function makeMutex() {
-	let chain = Promise.resolve();
-	return async function run(fn) {
-		const next = chain.then(() => fn());
-		chain = next.catch(() => void 0);
-		return next;
-	};
-}
-//#endregion
 //#region src/lib/wizard-ask-bridge.ts
 /**
 * WizardAskBridge — host-side promise broker for the `wizard_ask` MCP tool.
@@ -146,334 +117,32 @@ function createSecretVault() {
 	};
 }
 //#endregion
-//#region src/lib/agent/runner/sequence/orchestrator/queue.ts
-/**
-* The orchestrator task queue.
-*
-* In memory, synchronous, single-owner: one Node process drives the run, so
-* there is no locking. The queue imposes no execution policy — `nextRunnable`
-* returns every pending task whose dependencies are satisfied, and how many of
-* those run at once is decided by the task graph, not the queue.
-*
-* Every transition rewrites `<installDir>/.posthog-wizard-cache/queue.json`, a
-* small file holding the whole queue, handoffs included. It is the run's log
-* and the report's source. The whole cache folder is run-scoped and wiped when
-* the run ends.
-*/
-const TaskStatus = {
-	Pending: "pending",
-	Running: "running",
-	Done: "done",
-	Skipped: "skipped",
-	Failed: "failed"
-};
-const QUEUE_DIR_NAME = ".posthog-wizard-cache";
-const DEFAULT_MAX_ATTEMPTS = 2;
-function nowIso() {
-	return (/* @__PURE__ */ new Date()).toISOString();
-}
-/** Dropped in the cache folder so an orphaned copy explains itself. */
-const DELETE_ME_FILE = ".DELETE-ME.md";
-const DELETE_ME_BODY = `# Safe to delete
-
-This folder contains run artifacts from the PostHog Wizard. This should have
-been deleted if the Wizard has finished running. If this wasn't deleted for
-some reason, you can safely delete the entire \`${QUEUE_DIR_NAME}/\` folder.
-`;
-var QueueStore = class {
-	tasks = [];
-	onTransition;
-	runId;
-	queuePath;
-	constructor(installDir, runId, opts) {
-		this.onTransition = opts?.onTransition;
-		this.runId = runId;
-		const dir = path$1.join(installDir, QUEUE_DIR_NAME);
-		this.queuePath = path$1.join(dir, "queue.json");
-		fs$1.mkdirSync(dir, { recursive: true });
-		fs$1.writeFileSync(path$1.join(dir, DELETE_ME_FILE), DELETE_ME_BODY);
-	}
-	list() {
-		return this.tasks;
-	}
-	get(id) {
-		return this.tasks.find((t) => t.id === id);
-	}
-	/**
-	* Every pending task whose dependencies are all satisfied (`done` or
-	* `skipped`). A skipped dependency does not block downstream work.
-	*/
-	nextRunnable() {
-		const doneIds = new Set(this.tasks.filter((t) => t.status === TaskStatus.Done || t.status === TaskStatus.Skipped).map((t) => t.id));
-		return this.tasks.filter((t) => t.status === TaskStatus.Pending && t.dependsOn.every((d) => doneIds.has(d)));
-	}
-	/**
-	* True when no task is running and none can be started. Either everything
-	* is terminal, or the only pending tasks are blocked by a failed dependency.
-	*/
-	isDrained() {
-		if (this.tasks.some((t) => t.status === TaskStatus.Running)) return false;
-		return this.nextRunnable().length === 0;
-	}
-	summary() {
-		const counts = {
-			[TaskStatus.Pending]: 0,
-			[TaskStatus.Running]: 0,
-			[TaskStatus.Done]: 0,
-			[TaskStatus.Skipped]: 0,
-			[TaskStatus.Failed]: 0
-		};
-		for (const t of this.tasks) counts[t.status] += 1;
-		return {
-			...counts,
-			total: this.tasks.length
-		};
-	}
-	readHandoff(id) {
-		return this.get(id)?.handoff ?? null;
-	}
-	/** Handoffs of completed tasks of a given type, oldest first. */
-	readHandoffsByType(type) {
-		return this.tasks.filter((t) => t.type === type && t.handoff).map((t) => t.handoff);
-	}
-	enqueue(input) {
-		const task = {
-			id: randomUUID(),
-			type: input.type,
-			label: input.label,
-			status: TaskStatus.Pending,
-			dependsOn: input.dependsOn ?? [],
-			inputs: input.inputs ?? {},
-			model: input.model,
-			attempts: 0,
-			maxAttempts: input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
-			enqueuedBy: input.enqueuedBy ?? "orchestrator",
-			createdAt: nowIso()
-		};
-		this.tasks.push(task);
-		this.reflect();
-		this.notify("enqueue", task);
-		return task;
-	}
-	start(id) {
-		const t = this.require(id);
-		t.status = TaskStatus.Running;
-		t.startedAt = nowIso();
-		t.attempts += 1;
-		this.reflect();
-		this.notify("start", t);
-		return t;
-	}
-	complete(id, handoff) {
-		return this.finish(id, TaskStatus.Done, handoff);
-	}
-	/** Terminal: the agent could not do the task. Not done, not failed. */
-	skip(id, handoff) {
-		return this.finish(id, TaskStatus.Skipped, handoff);
-	}
-	fail(id, error, handoff) {
-		const t = this.require(id);
-		t.error = error;
-		return this.finish(id, TaskStatus.Failed, handoff);
-	}
-	/** Put a failed/running task back to pending for a retry within the run. */
-	requeue(id) {
-		const t = this.require(id);
-		t.status = TaskStatus.Pending;
-		t.startedAt = void 0;
-		t.finishedAt = void 0;
-		this.reflect();
-		this.notify("requeue", t);
-		return t;
-	}
-	finish(id, status, handoff) {
-		const t = this.require(id);
-		if (handoff) t.handoff = handoff;
-		t.status = status;
-		t.finishedAt = nowIso();
-		this.reflect();
-		this.notify(status === TaskStatus.Done ? "complete" : status === TaskStatus.Skipped ? "skip" : "fail", t);
-		return t;
-	}
-	reflect() {
-		const file = {
-			version: 1,
-			runId: this.runId,
-			tasks: this.tasks
-		};
-		writeJsonAtomic(this.queuePath, file);
-	}
-	notify(event, task) {
-		try {
-			this.onTransition?.(event, task);
-		} catch (error) {
-			analytics.captureException(error instanceof Error ? error : new Error(String(error)), {
-				step: "orchestrator_queue_listener",
-				event
-			});
-		}
-	}
-	require(id) {
-		const t = this.get(id);
-		if (!t) throw new Error(`No task ${id} in the queue`);
-		return t;
-	}
-};
-//#endregion
-//#region src/lib/agent/runner/sequence/orchestrator/queue-tools.ts
-/**
-* Orchestrator MCP tools, registered into the existing `wizard-tools` server when
-* a queue is present. They let the orchestrator agent and task agents grow the
-* queue, report completion with a structured handoff, and read prior handoffs.
-*
-* The guard logic and the apply functions are plain, exported, and unit-tested.
-* `buildOrchestratorTools` wraps them in the SDK `tool()` shape.
-*/
-function stableStringify(value) {
-	if (value === null || typeof value !== "object") return JSON.stringify(value);
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
-}
-function dedupKey(type, inputs) {
-	return `${type}::${stableStringify(inputs)}`;
-}
-/**
-* A backstop on total queue size. Tasks can enqueue tasks, so a misbehaving
-* type could grow the queue without bound. Keeping the graph small is the job
-* of good agent and skill design, not this number — it only stops a runaway.
-* The real flow is ~9 tasks, so this sits well clear of it.
-*/
-const MAX_QUEUE_TASKS = 30;
+//#region src/lib/fetch-retry.ts
 /**
-* Validate an enqueue. Structural checks only — a real type, real dependencies,
-* not a literal duplicate, and not past the runaway backstop. How much runs,
-* and in what shape, is the task graph's business, not a knob's.
+* Retry wrapper for fetching from the skills/agents server (GitHub releases in
+* production). GitHub releases blips transiently, so every fetch on the run's
+* critical path — skill menu, skill zips, agent menu, agent prompt bodies —
+* goes through here rather than a bare `fetch`.
 */
-function checkEnqueueGuards(ctx, args) {
-	const tasks = ctx.store.list();
-	if (tasks.length >= MAX_QUEUE_TASKS) return {
-		ok: false,
-		guard: "queue-full",
-		message: `The queue already holds ${tasks.length} tasks (cap ${MAX_QUEUE_TASKS}). Refine the existing tasks rather than adding more.`
-	};
-	if (!ctx.validTypes.includes(args.type)) return {
-		ok: false,
-		guard: "unknown-type",
-		message: `Unknown task type "${args.type}". Valid types: ${ctx.validTypes.join(", ")}.`
-	};
-	for (const dep of args.dependsOn ?? []) if (!ctx.store.get(dep)) return {
-		ok: false,
-		guard: "unknown-dep",
-		message: `Dependency "${dep}" is not a known task id.`
-	};
-	const key = dedupKey(args.type, args.inputs ?? {});
-	if (tasks.some((t) => t.status !== TaskStatus.Failed && dedupKey(t.type, t.inputs) === key)) return {
-		ok: false,
-		guard: "dedup",
-		message: `A "${args.type}" task with these inputs already exists.`
-	};
-	return { ok: true };
-}
-function applyEnqueue(ctx, args) {
-	const guard = checkEnqueueGuards(ctx, args);
-	if (!guard.ok) return guard;
-	return {
-		ok: true,
-		task: ctx.store.enqueue({
-			type: args.type,
-			label: args.label,
-			inputs: args.inputs ?? {},
-			dependsOn: args.dependsOn ?? [],
-			model: args.model,
-			enqueuedBy: ctx.currentTaskId ?? "orchestrator"
-		})
-	};
-}
-function applyComplete(ctx, args) {
-	const id = ctx.currentTaskId;
-	if (!id) return {
-		ok: false,
-		message: "complete_task can only be called by a running task agent."
-	};
-	if (args.status === TaskStatus.Failed) ctx.store.fail(id, {
-		type: "self-reported",
-		message: args.handoff.forNextAgent
-	}, args.handoff);
-	else if (args.status === TaskStatus.Skipped) ctx.store.skip(id, args.handoff);
-	else ctx.store.complete(id, args.handoff);
-	return { ok: true };
+const DEFAULT_TIMEOUT_MS = 6e4;
+const DEFAULT_MAX_ATTEMPTS = 3;
+const DEFAULT_BACKOFF_MS = 500;
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function applyReadHandoffs(ctx, args) {
-	if (args.taskId) {
-		const h = ctx.store.readHandoff(args.taskId);
-		return h ? [h] : [];
+/** Fetch a URL, retrying transient failures (network error or non-ok HTTP) with backoff. */
+async function fetchWithRetry(url, opts = {}) {
+	const { fetchImpl = fetch, sleepImpl = sleep, timeoutMs = DEFAULT_TIMEOUT_MS, maxAttempts = DEFAULT_MAX_ATTEMPTS, backoffMs = DEFAULT_BACKOFF_MS } = opts;
+	const failures = [];
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
+		const resp = await fetchImpl(url, { signal: AbortSignal.timeout(timeoutMs) });
+		if (!resp.ok) throw new Error(`HTTP ${resp.status} ${resp.statusText}`);
+		return resp;
+	} catch (err) {
+		failures.push(`attempt ${attempt}: ${err.message}`);
+		if (attempt < maxAttempts) await sleepImpl(backoffMs * 2 ** (attempt - 1));
 	}
-	if (args.type) return ctx.store.readHandoffsByType(args.type);
-	const currentId = ctx.currentTaskId;
-	const current = currentId ? ctx.store.get(currentId) : void 0;
-	if (!current) return [];
-	return current.dependsOn.map((depId) => ctx.store.readHandoff(depId)).filter((h) => h !== null);
-}
-const HANDOFF_SHAPE = {
-	goals: z.string().describe("What this task was asked to achieve."),
-	did: z.string().describe("What you actually did."),
-	forNextAgent: z.string().describe("What the next agent should know."),
-	filesTouched: z.array(z.string()).optional(),
-	conflict: z.string().optional().describe("A one-line summary of any conflict you could not cleanly resolve (e.g. a dependency or build conflict). Put full detail in your work; this line is surfaced to the user.")
-};
-function textResult(text, isError = false) {
-	return {
-		isError,
-		content: [{
-			type: "text",
-			text
-		}]
-	};
-}
-/**
-* Build the orchestrator tools in the SDK `tool()` shape. Called from
-* createWizardToolsServer only when a queue context is present.
-*/
-function buildOrchestratorTools(tool, ctx) {
-	return [
-		tool("enqueue_task", "Add a task to the orchestrator queue. Use it to seed work and to enqueue follow-up work you discover. Keep tasks small and discrete.", {
-			type: z.string().describe(`The task type. One of: ${ctx.validTypes.join(", ")}.`),
-			label: z.string().optional().describe("A short label for the UI — the action in a few words (e.g. \"Add the PostHog SDK\", \"Initialize PostHog\"). Leave out file names, class names, and other specifics."),
-			inputs: z.record(z.unknown()).optional(),
-			dependsOn: z.array(z.string()).optional().describe("Task ids that must be done before this task runs."),
-			model: z.string().optional(),
-			reason: z.string().describe("One line on why this task is needed.")
-		}, ((args) => {
-			const res = applyEnqueue(ctx, args);
-			if (!res.ok) {
-				analytics.wizardCapture("orchestrator guard tripped", {
-					guard: res.guard,
-					type: args.type
-				});
-				return textResult(res.message, true);
-			}
-			return textResult(JSON.stringify({ id: res.task.id }));
-		})),
-		tool("complete_task", "Report the outcome of your task. Always call this exactly once when you finish, with a structured handoff for the next agent. Use status 'skipped' when the task does not apply to this project and you cannot do it (say why in the handoff) — not 'done'.", {
-			status: z.enum([
-				"done",
-				"failed",
-				"skipped"
-			]),
-			handoff: z.object(HANDOFF_SHAPE)
-		}, ((args) => {
-			const res = applyComplete(ctx, args);
-			if (!res.ok) return textResult(res.message, true);
-			return textResult("ok");
-		})),
-		tool("read_handoffs", "Read structured handoffs from earlier tasks. With no argument, returns the handoffs of your dependencies.", {
-			type: z.string().optional(),
-			taskId: z.string().optional()
-		}, ((args) => {
-			const handoffs = applyReadHandoffs(ctx, args);
-			return textResult(JSON.stringify(handoffs, null, 2));
-		}))
-	];
+	throw new Error(`fetch ${url} failed — ${failures.join("; ")}`);
 }
 //#endregion
 //#region src/lib/wizard-tools.ts
@@ -492,22 +161,29 @@ async function getSDKModule() {
 	if (!_sdkModule) _sdkModule = await import("@anthropic-ai/claude-agent-sdk");
 	return _sdkModule;
 }
+/** Expand a bundle entry into one entry per variant, so the menu reads the same whether a group ships bundled or as zips. */
+function expandBundleEntry(entry) {
+	if (!entry.bundle || !entry.variants) return [entry];
+	return entry.variants.map((variant) => ({
+		...variant,
+		name: entry.name,
+		group: entry.group,
+		bundle: true,
+		downloadUrl: entry.downloadUrl
+	}));
+}
 /**
 * Fetch the skill menu from the skills server.
 * Returns parsed data on success, `null` on failure.
 */
-async function fetchSkillMenu(skillsBaseUrl) {
+async function fetchSkillMenu(skillsBaseUrl, opts = {}) {
+	const menuUrl = `${skillsBaseUrl}/skill-menu.json`;
 	try {
-		const menuUrl = `${skillsBaseUrl}/skill-menu.json`;
 		logToFile(`fetchSkillMenu: fetching from ${menuUrl}`);
-		const resp = await fetch(menuUrl);
-		if (resp.ok) {
-			const data = await resp.json();
-			logToFile(`fetchSkillMenu: loaded (${Object.keys(data.categories).length} categories)`);
-			return data;
-		}
-		logToFile(`fetchSkillMenu: failed with HTTP ${resp.status}`);
-		return null;
+		const data = await (await fetchWithRetry(menuUrl, opts)).json();
+		for (const [category, entries] of Object.entries(data.categories)) data.categories[category] = entries.flatMap(expandBundleEntry);
+		logToFile(`fetchSkillMenu: loaded (${Object.keys(data.categories).length} categories)`);
+		return data;
 	} catch (err) {
 		logToFile(`fetchSkillMenu: error: ${err.message}`);
 		return null;
@@ -530,25 +206,26 @@ function extractZipArchive(zip, destDir) {
 	}
 	return written;
 }
-const DOWNLOAD_TIMEOUT_MS = 6e4;
-const DOWNLOAD_MAX_ATTEMPTS = 3;
-const DOWNLOAD_BACKOFF_MS = 500;
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
+/** Unpack the one variant this entry names out of a bundle; the rest is noise and never hits disk. */
+function extractBundle(bundle, destDir, entryId) {
+	if (typeof bundle?.id !== "string" || typeof bundle?.variants !== "object" || bundle.variants === null) throw new Error("malformed bundle: expected { id, variants }");
+	const files = bundle.variants[entryId.slice(bundle.id.length + 1)];
+	if (!files) throw new Error(`bundle ${bundle.id} has no variant "${entryId}"`);
+	const root = path.resolve(destDir);
+	let written = 0;
+	for (const [entryPath, contents] of Object.entries(files)) {
+		const target = path.resolve(root, entryPath);
+		if (target !== root && !target.startsWith(root + path.sep)) throw new Error(`bundle entry escapes destination: ${entryPath}`);
+		fs.mkdirSync(path.dirname(target), { recursive: true });
+		fs.writeFileSync(target, contents);
+		written++;
+	}
+	return written;
 }
 /** Download a URL to a buffer, retrying transient failures with backoff. */
 async function downloadWithRetry(url, opts = {}) {
-	const { fetchImpl = fetch, sleepImpl = sleep, timeoutMs = DOWNLOAD_TIMEOUT_MS, maxAttempts = DOWNLOAD_MAX_ATTEMPTS, backoffMs = DOWNLOAD_BACKOFF_MS } = opts;
-	const failures = [];
-	for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
-		const resp = await fetchImpl(url, { signal: AbortSignal.timeout(timeoutMs) });
-		if (!resp.ok) throw new Error(`HTTP ${resp.status} ${resp.statusText}`);
-		return new Uint8Array(await resp.arrayBuffer());
-	} catch (err) {
-		failures.push(`attempt ${attempt}: ${err.message}`);
-		if (attempt < maxAttempts) await sleepImpl(backoffMs * 2 ** (attempt - 1));
-	}
-	throw new Error(`download failed — ${failures.join("; ")}`);
+	const resp = await fetchWithRetry(url, opts);
+	return new Uint8Array(await resp.arrayBuffer());
 }
 /**
 * Download and extract a skill.
@@ -560,9 +237,9 @@ async function downloadSkill(skillEntry, installDir, skillsRoot) {
 	let step = "download";
 	try {
 		fs.mkdirSync(skillDir, { recursive: true });
-		const zip = await downloadWithRetry(skillEntry.downloadUrl);
+		const data = await downloadWithRetry(skillEntry.downloadUrl);
 		step = "extract";
-		const fileCount = extractZipArchive(zip, skillDir);
+		const fileCount = skillEntry.bundle ? extractBundle(JSON.parse(Buffer.from(data).toString("utf8")), skillDir, skillEntry.id) : extractZipArchive(data, skillDir);
 		fs.writeFileSync(path.join(skillDir, ".posthog-wizard"), "");
 		logToFile(`downloadSkill: installed ${skillEntry.id} from ${skillEntry.downloadUrl} (${fileCount} files)`);
 		return { success: true };
@@ -1101,6 +778,6 @@ const WIZARD_TOOL_NAMES = {
 	readHandoffs: `mcp__${SERVER_NAME}__read_handoffs`
 };
 //#endregion
-export { installSkillById as a, resolveEnvPath as c, TaskStatus as d, createWizardAskBridge as f, fetchSkillMenu as i, QUEUE_DIR_NAME as l, createWizardToolsServer as n, mergeEnvValues as o, downloadSkill as r, parseEnvKeys as s, WIZARD_TOOL_NAMES as t, QueueStore as u };
+export { installSkillById as a, resolveEnvPath as c, fetchSkillMenu as i, fetchWithRetry as l, createWizardToolsServer as n, mergeEnvValues as o, downloadSkill as r, parseEnvKeys as s, WIZARD_TOOL_NAMES as t, createWizardAskBridge as u };
 
-//# sourceMappingURL=wizard-tools-BcuRxp1A.js.map
+//# sourceMappingURL=wizard-tools-Dg8o2lcH.js.map