pm4ai 0.0.73

package/dist/watch-emitter-uTmZ3oQd.mjs

@@ -0,0 +1,177 @@
+import { x as CONFIG_DIR } from "./utils-CpkOMuQN.mjs";
+import { c as watchEventSchema, r as lockSchema, s as safeParseJson, t as checkResultSchema } from "./schemas-Dsbtf6P2.mjs";
+import { spawn } from "bun";
+import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { homedir } from "node:os";
+import { createConnection, createServer } from "node:net";
+//#region src/check-cache.ts
+/** biome-ignore-all lint/suspicious/noEmptyBlockStatements: intentional catch-swallow */
+const checksDir = () => join(homedir(), CONFIG_DIR, "checks");
+const leadingSepRe = /^--/u;
+const safeFileName = (projectPath) => projectPath.replaceAll("/", "--").replace(leadingSepRe, "");
+const cachePath = (projectPath) => join(checksDir(), `${safeFileName(projectPath)}.json`);
+const lockPath = (projectPath) => join(checksDir(), `${safeFileName(projectPath)}.lock`);
+const readCheckResult = (projectPath) => {
+	const p = cachePath(projectPath);
+	if (!existsSync(p)) return;
+	try {
+		return safeParseJson(checkResultSchema, readFileSync(p, "utf8"));
+	} catch {}
+};
+const getHeadCommit = (projectPath) => {
+	try {
+		return execFileSync("git", ["rev-parse", "HEAD"], {
+			cwd: projectPath,
+			stdio: "pipe"
+		}).toString().trim();
+	} catch {}
+	return "";
+};
+const isCheckRunning = (projectPath) => {
+	const lp = lockPath(projectPath);
+	if (!existsSync(lp)) return false;
+	try {
+		const lock = safeParseJson(lockSchema, readFileSync(lp, "utf8"));
+		if (!lock) {
+			rmSync(lp);
+			return false;
+		}
+		if (Date.now() - new Date(lock.at).getTime() > 6e5) {
+			rmSync(lp);
+			return false;
+		}
+		try {
+			process.kill(lock.pid, 0);
+			return true;
+		} catch {
+			rmSync(lp);
+			return false;
+		}
+	} catch {
+		rmSync(lp);
+		return false;
+	}
+};
+const writeCheckResult = (opts) => {
+	mkdirSync(checksDir(), { recursive: true });
+	const result = {
+		at: (/* @__PURE__ */ new Date()).toISOString(),
+		commit: getHeadCommit(opts.projectPath),
+		pass: opts.pass,
+		summary: opts.summary,
+		violations: opts.violations
+	};
+	writeFileSync(cachePath(opts.projectPath), JSON.stringify(result));
+};
+const spawnBackgroundCheck = (projectPath) => {
+	if (isCheckRunning(projectPath)) return;
+	mkdirSync(checksDir(), { recursive: true });
+	spawn([
+		"bun",
+		join(import.meta.dir, "check-worker.js"),
+		projectPath
+	], {
+		stderr: "ignore",
+		stdin: "ignore",
+		stdout: "ignore"
+	}).unref();
+};
+//#endregion
+//#region src/watch-emitter.ts
+const SOCKET_DIR = join(homedir(), CONFIG_DIR);
+const SOCKET_PATH = join(SOCKET_DIR, "watch.sock");
+const clients = /* @__PURE__ */ new Set();
+const listeners = /* @__PURE__ */ new Set();
+let server;
+const removeSocket = () => {
+	try {
+		unlinkSync(SOCKET_PATH);
+	} catch {}
+};
+const broadcast = (line, exclude) => {
+	const msg = `${line}\n`;
+	for (const client of clients) if (client !== exclude) try {
+		client.write(msg);
+	} catch {}
+};
+const startEmitter = async () => {
+	if (server) return;
+	mkdirSync(SOCKET_DIR, { recursive: true });
+	if (existsSync(SOCKET_PATH)) removeSocket();
+	await new Promise((resolve, reject) => {
+		const s = createServer((socket) => {
+			clients.add(socket);
+			socket.on("close", () => clients.delete(socket));
+			socket.on("error", () => clients.delete(socket));
+			let buffer = "";
+			socket.on("data", (chunk) => {
+				buffer += chunk.toString();
+				const lines = buffer.split("\n");
+				buffer = lines.pop() ?? "";
+				for (const line of lines.filter(Boolean)) {
+					broadcast(line, socket);
+					const event = safeParseJson(watchEventSchema, line);
+					if (event) for (const fn of listeners) fn(event);
+				}
+			});
+		});
+		s.on("error", reject);
+		s.listen(SOCKET_PATH, () => {
+			server = s;
+			resolve();
+		});
+	});
+};
+const stopEmitter = async () => {
+	if (!server) return;
+	const s = server;
+	server = void 0;
+	for (const c of clients) c.destroy();
+	clients.clear();
+	await new Promise((resolve) => {
+		s.close(() => {
+			removeSocket();
+			resolve();
+		});
+	});
+};
+const emitToSocket = (event) => {
+	if (!existsSync(SOCKET_PATH)) return;
+	try {
+		const sock = createConnection(SOCKET_PATH);
+		sock.on("error", () => {});
+		sock.on("connect", () => {
+			sock.write(`${JSON.stringify(event)}\n`);
+			sock.end();
+		});
+	} catch {}
+};
+const cleanupOnExit = () => {
+	stopEmitter().catch(() => {});
+};
+const installCleanup = () => {
+	process.on("exit", () => {
+		if (server) {
+			for (const c of clients) c.destroy();
+			clients.clear();
+			server.close();
+			removeSocket();
+		}
+	});
+	process.on("SIGINT", () => {
+		cleanupOnExit();
+		process.exit(130);
+	});
+	process.on("SIGTERM", () => {
+		cleanupOnExit();
+		process.exit(143);
+	});
+};
+const onEvent = (fn) => {
+	listeners.add(fn);
+	return () => listeners.delete(fn);
+};
+//#endregion
+export { startEmitter as a, writeCheckResult as c, onEvent as i, emitToSocket as n, readCheckResult as o, installCleanup as r, spawnBackgroundCheck as s, SOCKET_PATH as t };

package/dist/watch-state-DIMHiLr5.d.mts

@@ -0,0 +1,118 @@
+//#region src/watch-types.d.ts
+interface WatchEvent {
+  at: string;
+  detail?: string;
+  project: string;
+  status: WatchStatus;
+  step: WatchStep;
+}
+type WatchStatus = 'fail' | 'ok' | 'start';
+type WatchStep = 'audit' | 'check' | 'done' | 'maintain' | 'sync';
+declare const WATCH_STEPS: readonly ["audit", "check", "done", "maintain", "sync"];
+declare const WATCH_STATUSES: readonly ["fail", "ok", "start"];
+interface CreateEventArgs {
+  detail?: string;
+  project: string;
+  status: WatchStatus;
+  step: WatchStep;
+}
+declare const createEvent: ({
+  detail,
+  project,
+  status,
+  step
+}: CreateEventArgs) => WatchEvent;
+//#endregion
+//#region src/watch-state.d.ts
+interface DerivedStats {
+  completedStepCount: number;
+  done: number;
+  eta?: number;
+  failed: number;
+  running: number;
+  slowestElapsed: number;
+  slowestName: string;
+}
+interface ProjectInfo {
+  name: string;
+  path: string;
+}
+interface ProjectState {
+  cachedPass?: boolean;
+  completedSteps: Set<string>;
+  detail?: string;
+  elapsed: number;
+  startedAt?: number;
+  status: 'done' | 'failed' | 'idle' | 'running';
+  step?: string;
+}
+type RunAction = {
+  event: WatchEvent;
+  type: 'event';
+} | {
+  focused: string;
+  type: 'focus';
+} | {
+  mkIdle: (p: ProjectInfo) => ProjectState;
+  projects: ProjectInfo[];
+  type: 'reset';
+} | {
+  type: 'bell-acked';
+} | {
+  type: 'tick';
+};
+interface RunState {
+  bellPending: boolean;
+  elapsed: number;
+  focused: string;
+  history: number[];
+  lastDone: number;
+  lastElapsed: number;
+  lastFailed: number;
+  lastTime: string;
+  phase: 'done' | 'idle' | 'running';
+  projects: Record<string, ProjectState>;
+  runCount: number;
+  sortSnapshot: string[];
+  startTime?: number;
+}
+declare const RESET_DELAY = 5000;
+declare const DISPLAY_STEPS: readonly ["sync", "audit", "maintain", "check"];
+declare const STEP_COUNT: 4;
+declare const STEP_LABELS: {
+  readonly audit: "🔍 auditing";
+  readonly check: "🧪 checking";
+  readonly maintain: "🔧 maintaining";
+  readonly sync: "📦 syncing";
+};
+declare const STATUS_ORDER: {
+  readonly done: 1;
+  readonly failed: 2;
+  readonly idle: 3;
+  readonly running: 0;
+};
+declare const MAX_HISTORY = 8;
+declare const IDLE_FALLBACK: ProjectState;
+declare const smoothBar: (fraction: number, width: number) => string;
+declare const sparkline: (values: number[]) => string;
+declare const progressDots: (completed: Set<string>, current?: string) => string;
+declare const formatTime: (seconds: number) => string;
+declare const timeAgo: (iso: string) => string;
+declare const nextProjectState: (prev: ProjectState, event: WatchEvent) => ProjectState;
+declare const sortByStatus: (names: string[], projects: Record<string, ProjectState>) => string[];
+declare const tickProjects: (projects: Record<string, ProjectState>) => Record<string, ProjectState>;
+declare const runReducer: (state: RunState, action: RunAction) => RunState;
+declare const deriveStats: ({
+  elapsed,
+  history,
+  lastElapsed,
+  projects
+}: {
+  elapsed: number;
+  history: number[];
+  lastElapsed: number;
+  projects: Record<string, ProjectState>;
+}) => DerivedStats;
+declare const createInitState: (projects: ProjectInfo[], mkIdle: (p: ProjectInfo) => ProjectState) => RunState;
+//#endregion
+export { createEvent as A, timeAgo as C, WatchEvent as D, WATCH_STEPS as E, WatchStatus as O, tickProjects as S, WATCH_STATUSES as T, progressDots as _, ProjectInfo as a, sortByStatus as b, RunAction as c, STEP_COUNT as d, STEP_LABELS as f, nextProjectState as g, formatTime as h, MAX_HISTORY as i, WatchStep as k, RunState as l, deriveStats as m, DerivedStats as n, ProjectState as o, createInitState as p, IDLE_FALLBACK as r, RESET_DELAY as s, DISPLAY_STEPS as t, STATUS_ORDER as u, runReducer as v, CreateEventArgs as w, sparkline as x, smoothBar as y };

package/dist/watch-state-wF-NfC-k.mjs

@@ -0,0 +1,274 @@
+//#region src/watch-state.ts
+const RESET_DELAY = 5e3;
+const DISPLAY_STEPS = [
+	"sync",
+	"audit",
+	"maintain",
+	"check"
+];
+const STEP_COUNT = DISPLAY_STEPS.length;
+const STEP_LABELS = {
+	audit: "🔍 auditing",
+	check: "🧪 checking",
+	maintain: "🔧 maintaining",
+	sync: "📦 syncing"
+};
+const STATUS_ORDER = {
+	done: 1,
+	failed: 2,
+	idle: 3,
+	running: 0
+};
+const BAR_CHARS = " ▏▎▍▌▋▊▉█";
+const BAR_FULL = BAR_CHARS.at(-1) ?? "█";
+const SPARK_CHARS = "▁▂▃▄▅▆▇█";
+const SPARK_ZERO = SPARK_CHARS[0] ?? "▁";
+const MAX_HISTORY = 8;
+const IDLE_FALLBACK = {
+	completedSteps: /* @__PURE__ */ new Set(),
+	elapsed: 0,
+	status: "idle"
+};
+const smoothBar = (fraction, width) => {
+	const total = Math.min(1, Math.max(0, fraction)) * width;
+	const full = Math.floor(total);
+	const partial = total - full;
+	const partialIdx = Math.round(partial * 8);
+	const partialChar = partialIdx > 0 && full < width ? BAR_CHARS[partialIdx] ?? "" : "";
+	const filled = full + (partialChar ? 1 : 0);
+	const empty = Math.max(0, width - filled);
+	return `${BAR_FULL.repeat(full)}${partialChar}${"░".repeat(empty)}`;
+};
+const sparkline = (values) => {
+	if (values.length === 0) return "";
+	let max = 0;
+	for (const v of values) if (v > max) max = v;
+	if (max === 0) return SPARK_ZERO.repeat(values.length);
+	return values.map((v) => SPARK_CHARS[Math.round(v / max * 7)] ?? SPARK_ZERO).join("");
+};
+const progressDots = (completed, current) => {
+	const parts = [];
+	for (const s of DISPLAY_STEPS) if (completed.has(s)) parts.push("●");
+	else if (s === current) parts.push("◌");
+	else parts.push("·");
+	return parts.join("");
+};
+const formatTime = (seconds) => {
+	if (seconds <= 0) return "<1s";
+	if (seconds < 60) return `${seconds}s`;
+	if (seconds < 3600) {
+		const m = Math.floor(seconds / 60);
+		const s = seconds % 60;
+		return `${m}m${s > 0 ? `${s}s` : ""}`;
+	}
+	const h = Math.floor(seconds / 3600);
+	const m = Math.floor(seconds % 3600 / 60);
+	return `${h}h${m > 0 ? `${m}m` : ""}`;
+};
+const timeAgo = (iso) => {
+	const ms = Date.now() - new Date(iso).getTime();
+	const mins = Math.floor(ms / 6e4);
+	if (mins < 1) return "just now";
+	if (mins < 60) return `${mins}m ago`;
+	const hours = Math.floor(mins / 60);
+	if (hours < 24) return `${hours}h ago`;
+	return `${Math.floor(hours / 24)}d ago`;
+};
+const nextProjectState = (prev, event) => {
+	if (event.step === "done") {
+		const projectElapsed = prev.startedAt ? Math.floor((Date.now() - prev.startedAt) / 1e3) : 0;
+		return event.status === "fail" ? {
+			completedSteps: new Set(DISPLAY_STEPS),
+			detail: event.detail,
+			elapsed: projectElapsed,
+			status: "failed"
+		} : {
+			completedSteps: new Set(DISPLAY_STEPS),
+			detail: event.detail ?? "clean",
+			elapsed: projectElapsed,
+			status: "done"
+		};
+	}
+	if (event.status === "start") {
+		const freshStart = prev.status === "done" || prev.status === "failed" || prev.status === "idle";
+		return {
+			completedSteps: freshStart ? /* @__PURE__ */ new Set() : prev.completedSteps,
+			elapsed: 0,
+			startedAt: freshStart ? Date.now() : prev.startedAt ?? Date.now(),
+			status: "running",
+			step: event.step
+		};
+	}
+	if (event.status === "fail") return {
+		completedSteps: prev.completedSteps,
+		detail: event.detail,
+		elapsed: prev.elapsed,
+		startedAt: prev.startedAt,
+		status: "running",
+		step: event.step
+	};
+	return {
+		completedSteps: prev.completedSteps.has(event.step) ? prev.completedSteps : new Set([...prev.completedSteps, event.step]),
+		detail: event.detail,
+		elapsed: prev.elapsed,
+		startedAt: prev.startedAt,
+		status: "running",
+		step: event.step
+	};
+};
+const sortByStatus = (names, projects) => [...names].toSorted((a, b) => {
+	const sa = projects[a]?.status ?? "idle";
+	const sb = projects[b]?.status ?? "idle";
+	return (STATUS_ORDER[sa] ?? 9) - (STATUS_ORDER[sb] ?? 9);
+});
+const tickProjects = (projects) => {
+	const now = Date.now();
+	let changed = false;
+	const next = {};
+	for (const [k, v] of Object.entries(projects)) {
+		const startedAt = v.status === "running" ? v.startedAt : void 0;
+		const elapsed = startedAt === void 0 ? v.elapsed : Math.floor((now - startedAt) / 1e3);
+		if (startedAt !== void 0 && elapsed !== v.elapsed) {
+			next[k] = {
+				...v,
+				elapsed
+			};
+			changed = true;
+		} else next[k] = v;
+	}
+	return changed ? next : projects;
+};
+const runReducer = (state, action) => {
+	if (action.type === "tick") {
+		if (!state.startTime) return state;
+		const projects = tickProjects(state.projects);
+		return {
+			...state,
+			elapsed: Math.floor((Date.now() - state.startTime) / 1e3),
+			projects
+		};
+	}
+	if (action.type === "bell-acked") return state.bellPending ? {
+		...state,
+		bellPending: false
+	} : state;
+	if (action.type === "focus") return state.focused === action.focused ? state : {
+		...state,
+		focused: action.focused
+	};
+	if (action.type === "reset") {
+		const newProjects = Object.fromEntries(action.projects.map((p) => [p.name, action.mkIdle(p)]));
+		let doneCount = 0;
+		let failedCount = 0;
+		for (const s of Object.values(state.projects)) {
+			if (s.status === "done") doneCount += 1;
+			if (s.status === "failed") failedCount += 1;
+		}
+		const snapshot = sortByStatus(Object.keys(newProjects), newProjects);
+		return {
+			...state,
+			bellPending: false,
+			elapsed: 0,
+			focused: snapshot[0] ?? state.focused,
+			history: state.elapsed > 0 ? [...state.history, state.elapsed].slice(-8) : state.history,
+			lastDone: doneCount,
+			lastElapsed: state.elapsed,
+			lastFailed: failedCount,
+			lastTime: (/* @__PURE__ */ new Date()).toLocaleTimeString(),
+			phase: "idle",
+			projects: newProjects,
+			runCount: state.runCount + 1,
+			sortSnapshot: snapshot,
+			startTime: void 0
+		};
+	}
+	const { event } = action;
+	const nextProj = nextProjectState(state.projects[event.project] ?? IDLE_FALLBACK, event);
+	const next = {
+		...state.projects,
+		[event.project]: nextProj
+	};
+	const startTime = event.status === "start" ? state.startTime ?? Date.now() : state.startTime;
+	let finished = 0;
+	let total = 0;
+	let hasRunning = false;
+	for (const s of Object.values(next)) {
+		total += 1;
+		if (s.status === "done" || s.status === "failed") finished += 1;
+		if (s.status === "running") hasRunning = true;
+	}
+	const wasRunning = state.phase === "running";
+	const phase = finished === total && total > 0 ? "done" : hasRunning ? "running" : state.phase;
+	const shouldResort = !wasRunning && phase === "running" || phase === "done";
+	const sortSnapshot = shouldResort ? sortByStatus(Object.keys(next), next) : state.sortSnapshot;
+	const bellPending = wasRunning && phase === "done" ? true : phase === "running" ? false : state.bellPending;
+	const focused = shouldResort && !sortSnapshot.includes(state.focused) ? sortSnapshot[0] ?? state.focused : state.focused;
+	return {
+		...state,
+		bellPending,
+		focused,
+		phase,
+		projects: next,
+		sortSnapshot,
+		startTime
+	};
+};
+const deriveStats = ({ elapsed, history, lastElapsed, projects }) => {
+	let runningCount = 0;
+	let doneCount = 0;
+	let failedCount = 0;
+	let steps = 0;
+	let maxE = 0;
+	let maxN = "";
+	for (const [n, s] of Object.entries(projects)) {
+		if (s.status === "running") runningCount += 1;
+		if (s.status === "done") doneCount += 1;
+		if (s.status === "failed") {
+			failedCount += 1;
+			steps += STEP_COUNT;
+		}
+		steps += s.completedSteps.size;
+		if ((s.status === "done" || s.status === "failed") && s.elapsed > maxE) {
+			maxE = s.elapsed;
+			maxN = n;
+		}
+	}
+	let eta;
+	if (runningCount > 0) {
+		if (history.length > 0) {
+			let sum = 0;
+			for (const h of history) sum += h;
+			eta = Math.max(0, Math.round(sum / history.length - elapsed));
+		} else if (lastElapsed > 0) eta = Math.max(0, lastElapsed - elapsed);
+	}
+	return {
+		completedStepCount: steps,
+		done: doneCount,
+		eta,
+		failed: failedCount,
+		running: runningCount,
+		slowestElapsed: maxE,
+		slowestName: maxN
+	};
+};
+const createInitState = (projects, mkIdle) => {
+	const initial = Object.fromEntries(projects.map((p) => [p.name, mkIdle(p)]));
+	const snapshot = sortByStatus(Object.keys(initial), initial);
+	return {
+		bellPending: false,
+		elapsed: 0,
+		focused: snapshot[0] ?? "",
+		history: [],
+		lastDone: 0,
+		lastElapsed: 0,
+		lastFailed: 0,
+		lastTime: "",
+		phase: "idle",
+		projects: initial,
+		runCount: 0,
+		sortSnapshot: snapshot,
+		startTime: void 0
+	};
+};
+//#endregion
+export { tickProjects as _, STATUS_ORDER as a, createInitState as c, nextProjectState as d, progressDots as f, sparkline as g, sortByStatus as h, RESET_DELAY as i, deriveStats as l, smoothBar as m, IDLE_FALLBACK as n, STEP_COUNT as o, runReducer as p, MAX_HISTORY as r, STEP_LABELS as s, DISPLAY_STEPS as t, formatTime as u, timeAgo as v };

package/dist/watch-state.d.mts

@@ -0,0 +1,2 @@
+import { C as timeAgo, S as tickProjects, _ as progressDots, a as ProjectInfo, b as sortByStatus, c as RunAction, d as STEP_COUNT, f as STEP_LABELS, g as nextProjectState, h as formatTime, i as MAX_HISTORY, l as RunState, m as deriveStats, n as DerivedStats, o as ProjectState, p as createInitState, r as IDLE_FALLBACK, s as RESET_DELAY, t as DISPLAY_STEPS, u as STATUS_ORDER, v as runReducer, x as sparkline, y as smoothBar } from "./watch-state-DIMHiLr5.mjs";
+export { DISPLAY_STEPS, type DerivedStats, IDLE_FALLBACK, MAX_HISTORY, type ProjectInfo, type ProjectState, RESET_DELAY, type RunAction, type RunState, STATUS_ORDER, STEP_COUNT, STEP_LABELS, createInitState, deriveStats, formatTime, nextProjectState, progressDots, runReducer, smoothBar, sortByStatus, sparkline, tickProjects, timeAgo };

package/dist/watch-state.mjs

@@ -0,0 +1,2 @@
+import { _ as tickProjects, a as STATUS_ORDER, c as createInitState, d as nextProjectState, f as progressDots, g as sparkline, h as sortByStatus, i as RESET_DELAY, l as deriveStats, m as smoothBar, n as IDLE_FALLBACK, o as STEP_COUNT, p as runReducer, r as MAX_HISTORY, s as STEP_LABELS, t as DISPLAY_STEPS, u as formatTime, v as timeAgo } from "./watch-state-wF-NfC-k.mjs";
+export { DISPLAY_STEPS, IDLE_FALLBACK, MAX_HISTORY, RESET_DELAY, STATUS_ORDER, STEP_COUNT, STEP_LABELS, createInitState, deriveStats, formatTime, nextProjectState, progressDots, runReducer, smoothBar, sortByStatus, sparkline, tickProjects, timeAgo };

package/dist/watch-types-BzSNCGb2.mjs

@@ -0,0 +1,22 @@
+//#region src/watch-types.ts
+const WATCH_STEPS = [
+	"audit",
+	"check",
+	"done",
+	"maintain",
+	"sync"
+];
+const WATCH_STATUSES = [
+	"fail",
+	"ok",
+	"start"
+];
+const createEvent = ({ detail, project, status, step }) => ({
+	at: (/* @__PURE__ */ new Date()).toISOString(),
+	...detail ? { detail } : {},
+	project,
+	status,
+	step
+});
+//#endregion
+export { WATCH_STEPS as n, createEvent as r, WATCH_STATUSES as t };

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "pm4ai",
+  "version": "0.0.73",
+  "description": "Agent-first anti-slop project management for TypeScript monorepos",
+  "keywords": [
+    "bun",
+    "lintmax",
+    "monorepo",
+    "project-manager",
+    "sync",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/1qh/pm4ai"
+  },
+  "license": "MIT",
+  "author": "1qh",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./guide": {
+      "types": "./dist/guide.d.mts",
+      "import": "./dist/guide.mjs"
+    },
+    "./schemas": {
+      "types": "./dist/schemas.d.mts",
+      "import": "./dist/schemas.mjs"
+    },
+    "./watch-state": {
+      "types": "./dist/watch-state.d.mts",
+      "import": "./dist/watch-state.mjs"
+    }
+  },
+  "bin": {
+    "pm4ai": "dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "prepublishOnly": "bun run build",
+    "postpublish": "bun ../../tools/prune-versions.ts",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "ink": "latest",
+    "ink-spinner": "latest",
+    "react": "latest",
+    "zod": "latest"
+  },
+  "requiredDevDeps": [
+    "lintmax",
+    "sherif",
+    "simple-git-hooks",
+    "tsdown",
+    "turbo",
+    "typescript",
+    "unrun"
+  ]
+}