@posthog/wizard 2.44.0 → 2.46.0

package/dist/queue-tools-CTUgbOU8.js

@@ -0,0 +1,366 @@
+import { n as analytics } from "./analytics-k76OWsl0.js";
+import * as fs$1 from "fs";
+import * as path$1 from "path";
+import { z } from "zod";
+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/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;
+/**
+* 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.
+*/
+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 };
+}
+function applyReadHandoffs(ctx, args) {
+	if (args.taskId) {
+		const h = ctx.store.readHandoff(args.taskId);
+		return h ? [h] : [];
+	}
+	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));
+		}))
+	];
+}
+//#endregion
+export { QUEUE_DIR_NAME as a, makeMutex as c, buildOrchestratorTools as i, writeJsonAtomic as l, applyEnqueue as n, QueueStore as o, applyReadHandoffs as r, TaskStatus as s, applyComplete as t };
+
+//# sourceMappingURL=queue-tools-CTUgbOU8.js.map

package/dist/queue-tools-CTUgbOU8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-tools-CTUgbOU8.js","names":["path"],"sources":["../src/utils/atomic-ledger.ts","../src/lib/agent/runner/sequence/orchestrator/queue.ts","../src/lib/agent/runner/sequence/orchestrator/queue-tools.ts"],"sourcesContent":["/**\n * Small shared primitives for on-disk ledgers: an atomic JSON writer and a\n * single-chain async mutex. Used by the audit tools and by the orchestrator\n * queue. Lifted here so both share one implementation.\n */\nimport * as fs from 'fs';\n\n/**\n * Atomically write JSON: write to a `.tmp` file then rename over the target. The\n * rename bumps the file's mtime in one step, which is what a file watcher polls.\n */\nexport function writeJsonAtomic(targetPath: string, data: unknown): void {\n  const tmpPath = `${targetPath}.tmp`;\n  fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf8');\n  fs.renameSync(tmpPath, targetPath);\n}\n\n/**\n * A single async mutex. Serializes read-modify-write cycles so concurrent callers\n * (parallel task agents, audit tool calls) never interleave a mutation.\n */\nexport function makeMutex() {\n  let chain: Promise<unknown> = Promise.resolve();\n  return async function run<T>(fn: () => Promise<T> | T): Promise<T> {\n    const next = chain.then(() => fn());\n    chain = next.catch(() => undefined);\n    return next;\n  };\n}\n","/**\n * The orchestrator task queue.\n *\n * In memory, synchronous, single-owner: one Node process drives the run, so\n * there is no locking. The queue imposes no execution policy — `nextRunnable`\n * returns every pending task whose dependencies are satisfied, and how many of\n * those run at once is decided by the task graph, not the queue.\n *\n * Every transition rewrites `<installDir>/.posthog-wizard-cache/queue.json`, a\n * small file holding the whole queue, handoffs included. It is the run's log\n * and the report's source. The whole cache folder is run-scoped and wiped when\n * the run ends.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { randomUUID } from 'crypto';\nimport { writeJsonAtomic } from '@utils/atomic-ledger';\nimport { analytics } from '@utils/analytics';\n\nexport const TaskStatus = {\n  Pending: 'pending',\n  Running: 'running',\n  Done: 'done',\n  Skipped: 'skipped',\n  Failed: 'failed',\n} as const;\n\nexport type TaskStatus = (typeof TaskStatus)[keyof typeof TaskStatus];\n\nexport interface QueuedTask {\n  id: string;\n  type: string;\n  /** Human-readable label for the TUI, set by the enqueuing agent. */\n  label?: string;\n  status: TaskStatus;\n  /**\n   * Ids of tasks that must finish before this one runs. Ids are generated at\n   * enqueue and dependsOn is never mutated, so a task can only depend on tasks\n   * created before it — the graph is a DAG by construction, cycles cannot\n   * form. Unknown ids are rejected by the enqueue_task guard.\n   */\n  dependsOn: string[];\n  inputs: Record<string, unknown>;\n  model?: string;\n  attempts: number;\n  maxAttempts: number;\n  /** The structured handoff the task reported on completion. */\n  handoff?: TaskHandoff;\n  /** 'orchestrator' for seeded tasks, or the id of the task that enqueued this one. */\n  enqueuedBy: string;\n  createdAt: string;\n  startedAt?: string;\n  finishedAt?: string;\n  error?: { type: string; message: string };\n}\n\nexport interface QueueFile {\n  version: 1;\n  runId: string;\n  tasks: QueuedTask[];\n}\n\n/** The structured handoff a task leaves for the next agent. */\nexport interface TaskHandoff {\n  goals: string;\n  did: string;\n  forNextAgent: string;\n  filesTouched?: string[];\n  /** A one-line summary of any unresolved conflict, surfaced in the outro. */\n  conflict?: string;\n}\n\nexport interface EnqueueInput {\n  type: string;\n  label?: string;\n  inputs?: Record<string, unknown>;\n  dependsOn?: string[];\n  model?: string;\n  maxAttempts?: number;\n  enqueuedBy?: string;\n}\n\nexport const QUEUE_DIR_NAME = '.posthog-wizard-cache';\nconst DEFAULT_MAX_ATTEMPTS = 2;\n\nfunction nowIso(): string {\n  return new Date().toISOString();\n}\n\n/** Dropped in the cache folder so an orphaned copy explains itself. */\nconst DELETE_ME_FILE = '.DELETE-ME.md';\nconst DELETE_ME_BODY = `# Safe to delete\n\nThis folder contains run artifacts from the PostHog Wizard. This should have\nbeen deleted if the Wizard has finished running. If this wasn't deleted for\nsome reason, you can safely delete the entire \\`${QUEUE_DIR_NAME}/\\` folder.\n`;\n\n/** Every queue transition, in the order it is reflected. */\nexport type TransitionEvent =\n  | 'enqueue'\n  | 'start'\n  | 'complete'\n  | 'skip'\n  | 'fail'\n  | 'requeue';\n\nexport interface QueueStoreOptions {\n  /**\n   * Called on every transition with the task's post-transition state. The\n   * runner uses it for telemetry; the store itself stays analytics-free.\n   * Listener errors are reported but cannot break a transition.\n   */\n  onTransition?: (event: TransitionEvent, task: QueuedTask) => void;\n}\n\nexport class QueueStore {\n  private tasks: QueuedTask[] = [];\n  private readonly onTransition?: (\n    event: TransitionEvent,\n    task: QueuedTask,\n  ) => void;\n\n  readonly runId: string;\n  readonly queuePath: string;\n\n  constructor(installDir: string, runId: string, opts?: QueueStoreOptions) {\n    this.onTransition = opts?.onTransition;\n    this.runId = runId;\n    const dir = path.join(installDir, QUEUE_DIR_NAME);\n    this.queuePath = path.join(dir, 'queue.json');\n    fs.mkdirSync(dir, { recursive: true });\n    fs.writeFileSync(path.join(dir, DELETE_ME_FILE), DELETE_ME_BODY);\n  }\n\n  // ── Reads ───────────────────────────────────────────────────────────\n\n  list(): readonly QueuedTask[] {\n    return this.tasks;\n  }\n\n  get(id: string): QueuedTask | undefined {\n    return this.tasks.find((t) => t.id === id);\n  }\n\n  /**\n   * Every pending task whose dependencies are all satisfied (`done` or\n   * `skipped`). A skipped dependency does not block downstream work.\n   */\n  nextRunnable(): QueuedTask[] {\n    const doneIds = new Set(\n      this.tasks\n        .filter(\n          (t) =>\n            t.status === TaskStatus.Done || t.status === TaskStatus.Skipped,\n        )\n        .map((t) => t.id),\n    );\n    return this.tasks.filter(\n      (t) =>\n        t.status === TaskStatus.Pending &&\n        t.dependsOn.every((d) => doneIds.has(d)),\n    );\n  }\n\n  /**\n   * True when no task is running and none can be started. Either everything\n   * is terminal, or the only pending tasks are blocked by a failed dependency.\n   */\n  isDrained(): boolean {\n    if (this.tasks.some((t) => t.status === TaskStatus.Running)) return false;\n    return this.nextRunnable().length === 0;\n  }\n\n  summary(): Record<TaskStatus, number> & { total: number } {\n    const counts: Record<TaskStatus, number> = {\n      [TaskStatus.Pending]: 0,\n      [TaskStatus.Running]: 0,\n      [TaskStatus.Done]: 0,\n      [TaskStatus.Skipped]: 0,\n      [TaskStatus.Failed]: 0,\n    };\n    for (const t of this.tasks) counts[t.status] += 1;\n    return { ...counts, total: this.tasks.length };\n  }\n\n  readHandoff(id: string): TaskHandoff | null {\n    return this.get(id)?.handoff ?? null;\n  }\n\n  /** Handoffs of completed tasks of a given type, oldest first. */\n  readHandoffsByType(type: string): TaskHandoff[] {\n    return this.tasks\n      .filter((t) => t.type === type && t.handoff)\n      .map((t) => t.handoff as TaskHandoff);\n  }\n\n  // ── Transitions (each one reflected to queue.json) ──────────────────\n\n  enqueue(input: EnqueueInput): QueuedTask {\n    const task: QueuedTask = {\n      id: randomUUID(),\n      type: input.type,\n      label: input.label,\n      status: TaskStatus.Pending,\n      dependsOn: input.dependsOn ?? [],\n      inputs: input.inputs ?? {},\n      model: input.model,\n      attempts: 0,\n      maxAttempts: input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,\n      enqueuedBy: input.enqueuedBy ?? 'orchestrator',\n      createdAt: nowIso(),\n    };\n    this.tasks.push(task);\n    this.reflect();\n    this.notify('enqueue', task);\n    return task;\n  }\n\n  start(id: string): QueuedTask {\n    const t = this.require(id);\n    t.status = TaskStatus.Running;\n    t.startedAt = nowIso();\n    t.attempts += 1;\n    this.reflect();\n    this.notify('start', t);\n    return t;\n  }\n\n  complete(id: string, handoff?: TaskHandoff): QueuedTask {\n    return this.finish(id, TaskStatus.Done, handoff);\n  }\n\n  /** Terminal: the agent could not do the task. Not done, not failed. */\n  skip(id: string, handoff?: TaskHandoff): QueuedTask {\n    return this.finish(id, TaskStatus.Skipped, handoff);\n  }\n\n  fail(\n    id: string,\n    error: { type: string; message: string },\n    handoff?: TaskHandoff,\n  ): QueuedTask {\n    const t = this.require(id);\n    t.error = error;\n    return this.finish(id, TaskStatus.Failed, handoff);\n  }\n\n  /** Put a failed/running task back to pending for a retry within the run. */\n  requeue(id: string): QueuedTask {\n    const t = this.require(id);\n    t.status = TaskStatus.Pending;\n    t.startedAt = undefined;\n    t.finishedAt = undefined;\n    this.reflect();\n    this.notify('requeue', t);\n    return t;\n  }\n\n  // ── Internals ───────────────────────────────────────────────────────\n\n  private finish(\n    id: string,\n    status: 'done' | 'skipped' | 'failed',\n    handoff?: TaskHandoff,\n  ): QueuedTask {\n    const t = this.require(id);\n    if (handoff) t.handoff = handoff;\n    t.status = status;\n    t.finishedAt = nowIso();\n    this.reflect();\n    this.notify(\n      status === TaskStatus.Done\n        ? 'complete'\n        : status === TaskStatus.Skipped\n        ? 'skip'\n        : 'fail',\n      t,\n    );\n    return t;\n  }\n\n  private reflect(): void {\n    const file: QueueFile = {\n      version: 1,\n      runId: this.runId,\n      tasks: this.tasks,\n    };\n    writeJsonAtomic(this.queuePath, file);\n  }\n\n  private notify(event: TransitionEvent, task: QueuedTask): void {\n    try {\n      this.onTransition?.(event, task);\n    } catch (error) {\n      // A listener must never break a transition, but its failure is a bug.\n      analytics.captureException(\n        error instanceof Error ? error : new Error(String(error)),\n        { step: 'orchestrator_queue_listener', event },\n      );\n    }\n  }\n\n  private require(id: string): QueuedTask {\n    const t = this.get(id);\n    if (!t) throw new Error(`No task ${id} in the queue`);\n    return t;\n  }\n}\n","/**\n * Orchestrator MCP tools, registered into the existing `wizard-tools` server when\n * a queue is present. They let the orchestrator agent and task agents grow the\n * queue, report completion with a structured handoff, and read prior handoffs.\n *\n * The guard logic and the apply functions are plain, exported, and unit-tested.\n * `buildOrchestratorTools` wraps them in the SDK `tool()` shape.\n */\nimport { z } from 'zod';\nimport { analytics } from '@utils/analytics';\nimport {\n  TaskStatus,\n  type QueueStore,\n  type QueuedTask,\n  type TaskHandoff,\n} from './queue';\n\nexport interface OrchestratorToolsContext {\n  store: QueueStore;\n  /** Task types the registry knows about. enqueue_task rejects anything else. */\n  validTypes: readonly string[];\n  /**\n   * The id of the task this tool server is bound to. Each task agent gets its\n   * own wizard-tools server, so attribution holds when independent tasks run\n   * in parallel. Absent for the seed, which is not a task.\n   */\n  currentTaskId?: string;\n}\n\nexport interface EnqueueArgs {\n  type: string;\n  label?: string;\n  inputs?: Record<string, unknown>;\n  dependsOn?: string[];\n  model?: string;\n  reason: string;\n}\n\nexport type GuardResult =\n  | { ok: true }\n  | { ok: false; guard: string; message: string };\n\nfunction stableStringify(value: unknown): string {\n  if (value === null || typeof value !== 'object') return JSON.stringify(value);\n  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;\n  const entries = Object.entries(value as Record<string, unknown>).sort(\n    ([a], [b]) => a.localeCompare(b),\n  );\n  return `{${entries\n    .map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`)\n    .join(',')}}`;\n}\n\nfunction dedupKey(type: string, inputs: Record<string, unknown>): string {\n  return `${type}::${stableStringify(inputs)}`;\n}\n\n/**\n * A backstop on total queue size. Tasks can enqueue tasks, so a misbehaving\n * type could grow the queue without bound. Keeping the graph small is the job\n * of good agent and skill design, not this number — it only stops a runaway.\n * The real flow is ~9 tasks, so this sits well clear of it.\n */\nconst MAX_QUEUE_TASKS = 30;\n\n/**\n * Validate an enqueue. Structural checks only — a real type, real dependencies,\n * not a literal duplicate, and not past the runaway backstop. How much runs,\n * and in what shape, is the task graph's business, not a knob's.\n */\nexport function checkEnqueueGuards(\n  ctx: OrchestratorToolsContext,\n  args: EnqueueArgs,\n): GuardResult {\n  const tasks = ctx.store.list();\n\n  if (tasks.length >= MAX_QUEUE_TASKS) {\n    return {\n      ok: false,\n      guard: 'queue-full',\n      message: `The queue already holds ${tasks.length} tasks (cap ${MAX_QUEUE_TASKS}). Refine the existing tasks rather than adding more.`,\n    };\n  }\n\n  if (!ctx.validTypes.includes(args.type)) {\n    return {\n      ok: false,\n      guard: 'unknown-type',\n      message: `Unknown task type \"${\n        args.type\n      }\". Valid types: ${ctx.validTypes.join(', ')}.`,\n    };\n  }\n\n  for (const dep of args.dependsOn ?? []) {\n    if (!ctx.store.get(dep)) {\n      return {\n        ok: false,\n        guard: 'unknown-dep',\n        message: `Dependency \"${dep}\" is not a known task id.`,\n      };\n    }\n  }\n\n  const key = dedupKey(args.type, args.inputs ?? {});\n  if (\n    tasks.some(\n      (t) =>\n        t.status !== TaskStatus.Failed && dedupKey(t.type, t.inputs) === key,\n    )\n  ) {\n    return {\n      ok: false,\n      guard: 'dedup',\n      message: `A \"${args.type}\" task with these inputs already exists.`,\n    };\n  }\n\n  return { ok: true };\n}\n\nexport type EnqueueResult =\n  | { ok: true; task: QueuedTask }\n  | { ok: false; guard: string; message: string };\n\nexport function applyEnqueue(\n  ctx: OrchestratorToolsContext,\n  args: EnqueueArgs,\n): EnqueueResult {\n  const guard = checkEnqueueGuards(ctx, args);\n  if (!guard.ok) return guard;\n\n  const task = ctx.store.enqueue({\n    type: args.type,\n    label: args.label,\n    inputs: args.inputs ?? {},\n    dependsOn: args.dependsOn ?? [],\n    model: args.model,\n    enqueuedBy: ctx.currentTaskId ?? 'orchestrator',\n  });\n  return { ok: true, task };\n}\n\nexport type CompleteResult = { ok: true } | { ok: false; message: string };\n\nexport function applyComplete(\n  ctx: OrchestratorToolsContext,\n  args: { status: 'done' | 'failed' | 'skipped'; handoff: TaskHandoff },\n): CompleteResult {\n  const id = ctx.currentTaskId;\n  if (!id) {\n    return {\n      ok: false,\n      message: 'complete_task can only be called by a running task agent.',\n    };\n  }\n  if (args.status === TaskStatus.Failed) {\n    ctx.store.fail(\n      id,\n      { type: 'self-reported', message: args.handoff.forNextAgent },\n      args.handoff,\n    );\n  } else if (args.status === TaskStatus.Skipped) {\n    ctx.store.skip(id, args.handoff);\n  } else {\n    ctx.store.complete(id, args.handoff);\n  }\n  return { ok: true };\n}\n\nexport function applyReadHandoffs(\n  ctx: OrchestratorToolsContext,\n  args: { type?: string; taskId?: string },\n): TaskHandoff[] {\n  if (args.taskId) {\n    const h = ctx.store.readHandoff(args.taskId);\n    return h ? [h] : [];\n  }\n  if (args.type) {\n    return ctx.store.readHandoffsByType(args.type);\n  }\n  // No filter: every handoff of a dependency of the current task.\n  const currentId = ctx.currentTaskId;\n  const current = currentId ? ctx.store.get(currentId) : undefined;\n  if (!current) return [];\n  return current.dependsOn\n    .map((depId) => ctx.store.readHandoff(depId))\n    .filter((h): h is TaskHandoff => h !== null);\n}\n\nconst HANDOFF_SHAPE = {\n  goals: z.string().describe('What this task was asked to achieve.'),\n  did: z.string().describe('What you actually did.'),\n  forNextAgent: z.string().describe('What the next agent should know.'),\n  filesTouched: z.array(z.string()).optional(),\n  conflict: z\n    .string()\n    .optional()\n    .describe(\n      '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.',\n    ),\n};\n\ntype SdkTool = (\n  name: string,\n  description: string,\n  // The SDK accepts a plain object of zod fields as the schema.\n  schema: Record<string, z.ZodTypeAny>,\n  handler: (args: never) => unknown,\n) => unknown;\n\nfunction textResult(text: string, isError = false) {\n  return { isError, content: [{ type: 'text' as const, text }] };\n}\n\n/**\n * Build the orchestrator tools in the SDK `tool()` shape. Called from\n * createWizardToolsServer only when a queue context is present.\n */\nexport function buildOrchestratorTools(\n  tool: SdkTool,\n  ctx: OrchestratorToolsContext,\n): unknown[] {\n  const enqueueTask = tool(\n    'enqueue_task',\n    '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.',\n    {\n      type: z\n        .string()\n        .describe(`The task type. One of: ${ctx.validTypes.join(', ')}.`),\n      label: z\n        .string()\n        .optional()\n        .describe(\n          '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.',\n        ),\n      inputs: z.record(z.unknown()).optional(),\n      dependsOn: z\n        .array(z.string())\n        .optional()\n        .describe('Task ids that must be done before this task runs.'),\n      model: z.string().optional(),\n      reason: z.string().describe('One line on why this task is needed.'),\n    },\n    ((args: EnqueueArgs) => {\n      const res = applyEnqueue(ctx, args);\n      if (!res.ok) {\n        analytics.wizardCapture('orchestrator guard tripped', {\n          guard: res.guard,\n          type: args.type,\n        });\n        return textResult(res.message, true);\n      }\n      return textResult(JSON.stringify({ id: res.task.id }));\n    }) as (args: never) => unknown,\n  );\n\n  const completeTask = tool(\n    'complete_task',\n    \"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'.\",\n    {\n      status: z.enum(['done', 'failed', 'skipped']),\n      handoff: z.object(HANDOFF_SHAPE),\n    },\n    ((args: {\n      status: 'done' | 'failed' | 'skipped';\n      handoff: TaskHandoff;\n    }) => {\n      const res = applyComplete(ctx, args);\n      if (!res.ok) return textResult(res.message, true);\n      return textResult('ok');\n    }) as (args: never) => unknown,\n  );\n\n  const readHandoffs = tool(\n    'read_handoffs',\n    'Read structured handoffs from earlier tasks. With no argument, returns the handoffs of your dependencies.',\n    {\n      type: z.string().optional(),\n      taskId: z.string().optional(),\n    },\n    ((args: { type?: string; taskId?: string }) => {\n      const handoffs = applyReadHandoffs(ctx, args);\n      return textResult(JSON.stringify(handoffs, null, 2));\n    }) as (args: never) => unknown,\n  );\n\n  return [enqueueTask, completeTask, readHandoffs];\n}\n"],"mappings":"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"}

package/dist/{registry-DcoBCMQR.js → registry-DT58jEYr.js}

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-B_-DWIq7.js";
-import { f as getUI } from "./debug-DXfQFmcM.js";
-import { a as createVersionBucket, c as detectAllPackageManagers, i as tryGetPackageJson } from "./setup-utils-BQCl28D8.js";
-import { n as getInstalledPackageVersion, r as hasDeclaredDependency, t as getDeclaredVersion } from "./package-json-CDs1ZVKu.js";
-import { a as gradlePackageManager, c as getPackageManagerName$1, i as detectPythonPackageManagers, l as getPythonVersion, n as composerPackageManager, o as swiftPackageManager, r as detectNodePackageManagers, s as detectPackageManager$1, t as bundlerPackageManager, u as getPythonVersionBucket } from "./package-manager-C6R_zpML.js";
+import { f as getUI } from "./debug-C9HmIrwx.js";
+import { a as createVersionBucket, c as detectAllPackageManagers, i as tryGetPackageJson } from "./setup-utils-Cb5uACEO.js";
+import { n as getInstalledPackageVersion, r as hasDeclaredDependency, t as getDeclaredVersion } from "./package-json-DCuoye-H.js";
+import { a as gradlePackageManager, c as getPackageManagerName$1, i as detectPythonPackageManagers, l as getPythonVersion, n as composerPackageManager, o as swiftPackageManager, r as detectNodePackageManagers, s as detectPackageManager$1, t as bundlerPackageManager, u as getPythonVersionBucket } from "./package-manager-CAD9Uklp.js";
 import * as semver from "semver";
 import { major, minVersion } from "semver";
 import path from "path";
@@ -10,19 +10,6 @@ import * as path$1 from "node:path";
 import * as fs$1 from "node:fs";
 import fg from "fast-glob";
 import fs from "fs/promises";
-//#region src/lib/framework-config.ts
-/**
-* Default package installation instruction used when frameworks don't
-* provide their own. Frameworks with specific needs (e.g., Swift SPM,
-* Composer) override this in their config.
-*/
-const DEFAULT_PACKAGE_INSTALLATION = "Use the detect_package_manager tool to determine the package manager. Do not manually edit package.json; the package manager handles it automatically.";
-const PYTHON_PACKAGE_INSTALLATION = "Use the detect_package_manager tool to determine the package manager. If the detected tool manages dependencies directly (e.g. uv add, poetry add), use it — it will update the manifest automatically. If using pip, you must also add the dependency to requirements.txt or the appropriate manifest file.";
-/**
-* Shared spinner message for all frameworks
-*/
-const SPINNER_MESSAGE = "Writing your PostHog setup with events, error capture and more...";
-//#endregion
 //#region src/frameworks/nextjs/utils.ts
 const getNextJsVersionBucket = createVersionBucket();
 const IGNORE_PATTERNS$9 = [
@@ -810,6 +797,19 @@ const ASTRO_AGENT_CONFIG = {
 	}
 };
 //#endregion
+//#region src/lib/framework-config.ts
+/**
+* Default package installation instruction used when frameworks don't
+* provide their own. Frameworks with specific needs (e.g., Swift SPM,
+* Composer) override this in their config.
+*/
+const DEFAULT_PACKAGE_INSTALLATION = "Use the detect_package_manager tool to determine the package manager. Do not manually edit package.json; the package manager handles it automatically.";
+const PYTHON_PACKAGE_INSTALLATION = "Use the detect_package_manager tool to determine the package manager. If the detected tool manages dependencies directly (e.g. uv add, poetry add), use it — it will update the manifest automatically. If using pip, you must also add the dependency to requirements.txt or the appropriate manifest file.";
+/**
+* Shared spinner message for all frameworks
+*/
+const SPINNER_MESSAGE = "Writing your PostHog setup with events, error capture and more...";
+//#endregion
 //#region src/frameworks/django/utils.ts
 const IGNORE_PATTERNS$5 = [
 	"**/node_modules/**",
@@ -2071,6 +2071,83 @@ const SWIFT_AGENT_CONFIG = {
 	}
 };
 //#endregion
+//#region src/frameworks/kmp/kmp-wizard-agent.ts
+const KMP_AGENT_CONFIG = {
+	metadata: {
+		name: "Kotlin Multiplatform",
+		integration: "kmp",
+		beta: true,
+		docsUrl: "https://posthog.com/docs/libraries/kmp",
+		preRunNotice: "The PostHog Kotlin Multiplatform SDK is in early access (0.x pre-release). The API may change between minor versions."
+	},
+	detection: {
+		packageName: "posthog-kmp",
+		packageDisplayName: "Kotlin Multiplatform",
+		usesPackageJson: false,
+		getVersion: () => void 0,
+		detectPackageManager: gradlePackageManager,
+		detect: async (options) => {
+			const { installDir } = options;
+			const buildFiles = await fg(["**/build.gradle", "**/build.gradle.kts"], {
+				cwd: installDir,
+				ignore: [
+					"**/build/**",
+					"**/node_modules/**",
+					"**/.gradle/**"
+				]
+			});
+			for (const file of buildFiles) {
+				const content = fs$1.readFileSync(path$1.join(installDir, file), "utf-8");
+				if (content.includes("kotlin(\"multiplatform\")") || content.includes("org.jetbrains.kotlin.multiplatform") || content.includes("kotlin-multiplatform")) return true;
+			}
+			return (await fg("**/src/commonMain", {
+				cwd: installDir,
+				onlyDirectories: true,
+				ignore: [
+					"**/build/**",
+					"**/node_modules/**",
+					"**/.gradle/**"
+				]
+			})).length > 0;
+		}
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: () => ({}) },
+	prompts: {
+		projectTypeDetection: "This is a Kotlin Multiplatform (KMP) project. Look for a build.gradle.kts (or build.gradle) that applies the Kotlin Multiplatform plugin (kotlin(\"multiplatform\") or org.jetbrains.kotlin.multiplatform) and a shared module with a src/commonMain source set.",
+		packageInstallation: "Add the PostHog KMP SDK to the shared module's commonMain dependencies in build.gradle.kts: within the kotlin { sourceSets { ... } } block, add implementation(\"com.posthog:posthog-kmp:<VERSION>\") to commonMain.dependencies. Match the existing dependency format (Groovy vs Kotlin DSL).",
+		getAdditionalContextLines: () => [
+			"Framework docs ID: kmp (use posthog://docs/frameworks/kmp for documentation)",
+			"Initialize once, early in the app lifecycle, from shared code. All PostHog APIs live in the com.posthog.kmp package.",
+			"Setup call: PostHog.setup(config = PostHogConfig(apiKey = \"<POSTHOG_PROJECT_TOKEN>\", host = \"<POSTHOG_HOST>\"), context = PostHogContext())",
+			"PostHogContext is platform-specific: on Android pass the Application via PostHogContext(application); on iOS and Web use the no-argument PostHogContext().",
+			"Imports: com.posthog.kmp.PostHog, com.posthog.kmp.PostHogConfig, com.posthog.kmp.PostHogContext."
+		]
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: () => [
+			"Analyzed your Kotlin Multiplatform project structure",
+			"Added the PostHog KMP SDK to your shared module",
+			"Configured PostHog initialization in your shared code",
+			"Added event capture and user identification"
+		],
+		getOutroNextSteps: () => [
+			"Wire up the platform-specific PostHogContext for each target (Android/iOS/Web)",
+			"Build and run your app to see PostHog in action",
+			"Visit your PostHog dashboard to see incoming events",
+			"Check out the PostHog KMP docs for feature flags, session replay, and more"
+		]
+	}
+};
+//#endregion
 //#region src/frameworks/android/utils.ts
 const IGNORE_PATTERNS$2 = [
 	"**/build/**",
@@ -2898,6 +2975,7 @@ const FRAMEWORK_REGISTRY = {
 	["fastapi"]: FASTAPI_AGENT_CONFIG,
 	["laravel"]: LARAVEL_AGENT_CONFIG,
 	["sveltekit"]: SVELTEKIT_AGENT_CONFIG,
+	["kmp"]: KMP_AGENT_CONFIG,
 	["swift"]: SWIFT_AGENT_CONFIG,
 	["android"]: ANDROID_AGENT_CONFIG,
 	["rails"]: RAILS_AGENT_CONFIG,
@@ -2909,4 +2987,4 @@ const FRAMEWORK_REGISTRY = {
 //#endregion
 export { SPINNER_MESSAGE as i, registry_exports as n, DEFAULT_PACKAGE_INSTALLATION as r, FRAMEWORK_REGISTRY as t };
 
-//# sourceMappingURL=registry-DcoBCMQR.js.map
+//# sourceMappingURL=registry-DT58jEYr.js.map