pm4ai 0.0.73

package/dist/fix-BcMN_cuG.mjs

@@ -0,0 +1,260 @@
+import { f as projectName, u as isInsideProject, x as CONFIG_DIR } from "./utils-CpkOMuQN.mjs";
+import { r as lockSchema, s as safeParseJson } from "./schemas-Dsbtf6P2.mjs";
+import { t as audit } from "./audit-oQQfgtxr.mjs";
+import { c as writeCheckResult, n as emitToSocket } from "./watch-emitter-uTmZ3oQd.mjs";
+import { n as discoverSources, t as discover } from "./discover-d8ENQC1K.mjs";
+import { a as syncPackageJson, c as syncUi, i as syncFumadocsGithubUrl, n as syncConfigs, o as syncSubPackages, r as syncFumadocsBuild, s as syncTsconfig, t as syncClaudeMd } from "./sync-DN1rgN3P.mjs";
+import { r as createEvent } from "./watch-types-BzSNCGb2.mjs";
+import { $ } from "bun";
+import { closeSync, copyFileSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+//#region src/log.ts
+const logDir = join(homedir(), CONFIG_DIR, "logs");
+const leadingSepRe = /^--/u;
+const logPath = (path) => join(logDir, `${path.replaceAll("/", "--").replace(leadingSepRe, "")}.json`);
+const updateLog = (entry) => {
+	mkdirSync(logDir, { recursive: true });
+	writeFileSync(logPath(entry.path), JSON.stringify(entry));
+};
+//#endregion
+//#region src/fix.ts
+const violationRe = /(?<count>\d+)\s*(?:error|violation|problem|issue)/iu;
+const maintain = async (projectPath) => {
+	const issues = [];
+	if (!existsSync(join(projectPath, "up.sh"))) {
+		issues.push({
+			detail: "missing, cannot maintain",
+			type: "up.sh"
+		});
+		return issues;
+	}
+	const result = await $`sh up.sh`.cwd(projectPath).quiet().nothrow();
+	const { exitCode } = result;
+	const stderr = [result.stdout.toString(), result.stderr.toString()].join("\n").trim();
+	if (exitCode === 0) {
+		const snapshotDir = join(homedir(), CONFIG_DIR, "snapshots", projectName(projectPath));
+		const lockfile = join(projectPath, "bun.lock");
+		if (existsSync(lockfile)) {
+			mkdirSync(snapshotDir, { recursive: true });
+			copyFileSync(lockfile, join(snapshotDir, "bun.lock"));
+		}
+		writeCheckResult({
+			pass: true,
+			projectPath,
+			violations: 0
+		});
+	} else {
+		const errorLine = stderr.split("\n").findLast(Boolean) ?? "unknown error";
+		issues.push({
+			detail: `failed: ${errorLine}`,
+			type: "up.sh"
+		});
+		const violationMatch = violationRe.exec(stderr);
+		writeCheckResult({
+			pass: false,
+			projectPath,
+			summary: errorLine,
+			violations: violationMatch?.groups?.count ? Number.parseInt(violationMatch.groups.count, 10) : 1
+		});
+	}
+	updateLog({
+		at: (/* @__PURE__ */ new Date()).toISOString(),
+		error: exitCode === 0 ? void 0 : stderr.slice(0, 500),
+		pass: exitCode === 0,
+		path: projectPath,
+		project: projectName(projectPath)
+	});
+	return issues;
+};
+const fix = async (all = false, excludes = []) => {
+	const lockFile = join(homedir(), CONFIG_DIR, "fix.lock");
+	mkdirSync(join(homedir(), CONFIG_DIR), { recursive: true });
+	const lockData = JSON.stringify({
+		at: (/* @__PURE__ */ new Date()).toISOString(),
+		pid: process.pid
+	});
+	const tryAcquireLock = () => {
+		try {
+			const fd = openSync(lockFile, "wx");
+			writeFileSync(fd, lockData);
+			closeSync(fd);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	if (!tryAcquireLock()) {
+		try {
+			const lock = safeParseJson(lockSchema, readFileSync(lockFile, "utf8"));
+			if (!lock) return;
+			const age = Date.now() - new Date(lock.at).getTime();
+			let alive = false;
+			try {
+				process.kill(lock.pid, 0);
+				alive = true;
+			} catch {}
+			if (alive && age < 6e5) {
+				console.log("another fix is already running");
+				return;
+			}
+		} catch {}
+		rmSync(lockFile, { force: true });
+		if (!tryAcquireLock()) {
+			console.log("another fix is already running");
+			return;
+		}
+	}
+	try {
+		const resolveTargets = async () => {
+			if (all) return discover(void 0, excludes);
+			const projectPath = await isInsideProject();
+			if (projectPath) {
+				const { self, cnsync } = await discoverSources();
+				return {
+					cnsync,
+					consumers: [{
+						isCnsync: false,
+						isSelf: false,
+						name: projectName(projectPath),
+						path: projectPath
+					}],
+					self
+				};
+			}
+			return discover(void 0, excludes);
+		};
+		const { cnsync, consumers, self } = await resolveTargets();
+		console.log(`found ${consumers.length} projects`);
+		console.log();
+		const allRepos = [
+			self,
+			cnsync,
+			...consumers
+		];
+		const blocked = [];
+		const pullable = [];
+		const checkResults = await Promise.all(allRepos.map(async (repo) => {
+			const name = projectName(repo.path);
+			if ((await $`git status --porcelain`.cwd(repo.path).quiet().nothrow()).stdout.toString().trim()) return {
+				name,
+				reason: "uncommitted changes"
+			};
+			await $`git fetch`.cwd(repo.path).quiet().nothrow();
+			const behind = await $`git rev-list --count HEAD..@{u}`.cwd(repo.path).quiet().nothrow();
+			const ahead = await $`git rev-list --count @{u}..HEAD`.cwd(repo.path).quiet().nothrow();
+			const b = Number.parseInt(behind.stdout.toString().trim(), 10);
+			const a = Number.parseInt(ahead.stdout.toString().trim(), 10);
+			if (b > 0 && a > 0) return {
+				name,
+				reason: `diverged (${b} behind, ${a} ahead)`
+			};
+			if (a > 0) return {
+				name,
+				reason: `${a} commits ahead, push first`
+			};
+			return {
+				behind: b,
+				name,
+				path: repo.path
+			};
+		}));
+		for (const r of checkResults) if ("reason" in r) blocked.push(`${r.name}: ${r.reason}`);
+		else if (r.behind > 0) pullable.push({
+			name: r.name,
+			path: r.path
+		});
+		if (blocked.length > 0) {
+			console.log("fix requires clean git state:");
+			for (const msg of blocked) console.log(`  ${msg}`);
+			return;
+		}
+		await Promise.all(pullable.map(async (repo) => {
+			await $`git pull`.cwd(repo.path).quiet().nothrow();
+			console.log(`${repo.name}: pulled`);
+		}));
+		const selfSubPkgIssues = await syncSubPackages(self.path, self.path);
+		if (selfSubPkgIssues.length > 0) for (const i of selfSubPkgIssues) console.log(`  ${i.type} ${i.detail}`);
+		const allTargets = [cnsync, ...consumers];
+		const tasks = allTargets.map(async (project) => {
+			const name = projectName(project.path);
+			const issues = [];
+			emitToSocket(createEvent({
+				project: name,
+				status: "start",
+				step: "sync"
+			}));
+			const [configIssues, claudeIssues, pkgIssues, tsconfigIssues, fumadocsBuildIssues, fumadocsGithubIssues] = await Promise.all([
+				syncConfigs(self.path, project.path),
+				syncClaudeMd(self.path, project.path),
+				syncPackageJson(project.path, self.path),
+				syncTsconfig(project.path),
+				syncFumadocsBuild(project.path),
+				syncFumadocsGithubUrl(project.path)
+			]);
+			const subPkgIssues = await syncSubPackages(self.path, project.path);
+			issues.push(...configIssues, ...claudeIssues, ...pkgIssues, ...tsconfigIssues, ...fumadocsBuildIssues, ...fumadocsGithubIssues, ...subPkgIssues);
+			if (existsSync(join(project.path, "readonly/ui"))) issues.push(...syncUi(cnsync.path, project.path));
+			const syncCount = issues.filter((i) => i.type === "synced").length;
+			emitToSocket(createEvent({
+				detail: syncCount > 0 ? `${syncCount} synced` : void 0,
+				project: name,
+				status: "ok",
+				step: "sync"
+			}));
+			emitToSocket(createEvent({
+				project: name,
+				status: "start",
+				step: "audit"
+			}));
+			const auditIssues = await audit(project.path);
+			issues.push(...auditIssues);
+			emitToSocket(createEvent({
+				detail: auditIssues.length > 0 ? `${auditIssues.length} issues` : void 0,
+				project: name,
+				status: auditIssues.length > 0 ? "fail" : "ok",
+				step: "audit"
+			}));
+			emitToSocket(createEvent({
+				project: name,
+				status: "start",
+				step: "maintain"
+			}));
+			const maintainIssues = await maintain(project.path);
+			issues.push(...maintainIssues);
+			const maintainDetail = maintainIssues[0]?.detail;
+			emitToSocket(createEvent({
+				detail: maintainDetail,
+				project: name,
+				status: maintainIssues.length > 0 ? "fail" : "ok",
+				step: "maintain"
+			}));
+			const changed = (await $`git status --porcelain`.cwd(project.path).quiet().nothrow()).stdout.toString().trim();
+			const fileCount = changed ? changed.split("\n").length : 0;
+			emitToSocket(createEvent({
+				detail: fileCount > 0 ? `${fileCount} files modified` : "clean",
+				project: name,
+				status: "ok",
+				step: "done"
+			}));
+			if (issues.length > 0) {
+				const lines = [project.path, ...issues.map((i) => `  ${i.type} ${i.detail}`)];
+				console.log(lines.join("\n"));
+				console.log();
+			}
+		});
+		await Promise.all(tasks);
+		console.log("--- changes ---");
+		const summaries = await Promise.all(allTargets.map(async (project) => {
+			const changed = (await $`git status --porcelain`.cwd(project.path).quiet().nothrow()).stdout.toString().trim();
+			const count = changed ? changed.split("\n").length : 0;
+			return count > 0 ? `${projectName(project.path)}: ${count} files modified` : `${projectName(project.path)}: clean`;
+		}));
+		for (const s of summaries) console.log(s);
+		if (process.platform === "darwin") await $`open swiftbar://refreshplugin?name=pm4ai`.quiet().nothrow();
+	} finally {
+		rmSync(lockFile, { force: true });
+	}
+};
+//#endregion
+export { maintain as n, fix as t };

package/dist/fix-DvtItv_V.mjs

@@ -0,0 +1,2 @@
+import { t as fix } from "./fix-BcMN_cuG.mjs";
+export { fix };

package/dist/guide-BS7-RqpH.d.mts

@@ -0,0 +1,4 @@
+//#region src/guide.d.ts
+declare const guide = "pm4ai \u2014 agent-first anti-slop project management for TypeScript monorepos\ndiscovers projects by scanning for lintmax in package.json deps\ndiscovers itself and cnsync the same way (auto-clones if not found)\ncontext-aware: inside a project, operates on that project only\ncommands:\n  pm4ai            this guide\n  pm4ai status     check current project (or all if outside a project)\n  pm4ai fix        sync + maintain current project (requires clean git)\n  pm4ai init <n>   scaffold a new pm4ai-ready project\n  pm4ai watch      live terminal dashboard (connects to running fix/status)\n  pm4ai ignores    rank lint suppressions by frequency across projects\n  pm4ai dashboard  local web dashboard at http://localhost:4200\n  pm4ai setup      install swiftbar menubar plugin + launchd daily auto-run\nflags:\n  --all            force global scan across all projects\n  --swiftbar       output in SwiftBar menubar format\n  --json           (watch) output raw newline-delimited JSON events\n  --verbose        print debug info to stderr\nfix behavior:\n  blocks if git is dirty or ahead (unpushed)\n  pulls clean repos before syncing\n  syncs: .github/workflows/ci.yml, clean.sh, up.sh, bunfig.toml, .gitignore, CLAUDE.md, readonly/ui\n  maintains: runs sh up.sh (clean + install + build + fix + check)\n  shows file change summary after completion\nstatus output (only issues shown, healthy projects omitted):\n  /path/to/project\n    git 3 uncommitted changes\n    file clean.sh out of sync\n    missing turbo.json\n    drift clean should start with \"sh clean.sh\"\n    dep react should be \"latest\" or \"^major\"\n    duplicate ai already provided by workspace dep\n    forbidden npm found, use bun only\n    ci failed 2026-04-02\n    deploy vercel deployment failed\nchecks:\n  git status (auto-pulls clean repos)\n  config drift (synced files match source)\n  missing infra (turbo.json, tsconfig.json, ci.yml)\n  root package.json (private, packageManager, hooks, sherif, prepare, clean)\n  tsconfig extends lintmax/tsconfig, no include\n  vercel.json installCommand is bun i\n  vercel deployment status\n  layout conventions (suppressHydrationWarning, antialiased, tracking, min-h-screen, font-sans, metadata, fonts.ts, providers.tsx, global.css, arrow function export, no RootLayout, no Provider inline)\n  page conventions (arrow function export)\n  next.config (reactStrictMode, no redundant postcss in apps)\n  app tsconfig (extends lintmax, no include)\n  banned packages (817 entries), bun globals, @a/ui deep imports\n  deps on latest or ^major, no duplicates across workspaces\n  no npm/yarn/pnpm in scripts or lockfiles\n  turbo scripts have --output-logs=errors-only\n  published packages have type:module, exports, files, license, repository\n  workspace devDependencies hoisted to root\n  no nested .gitignore, no postcss.config.mjs, no @ts-nocheck\n  no bun.lock tracked in git, no redundant clean scripts\n  ci status via github api";
+//#endregion
+export { guide as t };

package/dist/guide-CifUmtQN.mjs

@@ -0,0 +1,59 @@
+//#region src/guide.ts
+const guide = `pm4ai — agent-first anti-slop project management for TypeScript monorepos
+discovers projects by scanning for lintmax in package.json deps
+discovers itself and cnsync the same way (auto-clones if not found)
+context-aware: inside a project, operates on that project only
+commands:
+  pm4ai            this guide
+  pm4ai status     check current project (or all if outside a project)
+  pm4ai fix        sync + maintain current project (requires clean git)
+  pm4ai init <n>   scaffold a new pm4ai-ready project
+  pm4ai watch      live terminal dashboard (connects to running fix/status)
+  pm4ai ignores    rank lint suppressions by frequency across projects
+  pm4ai dashboard  local web dashboard at http://localhost:4200
+  pm4ai setup      install swiftbar menubar plugin + launchd daily auto-run
+flags:
+  --all            force global scan across all projects
+  --swiftbar       output in SwiftBar menubar format
+  --json           (watch) output raw newline-delimited JSON events
+  --verbose        print debug info to stderr
+fix behavior:
+  blocks if git is dirty or ahead (unpushed)
+  pulls clean repos before syncing
+  syncs: .github/workflows/ci.yml, clean.sh, up.sh, bunfig.toml, .gitignore, CLAUDE.md, readonly/ui
+  maintains: runs sh up.sh (clean + install + build + fix + check)
+  shows file change summary after completion
+status output (only issues shown, healthy projects omitted):
+  /path/to/project
+    git 3 uncommitted changes
+    file clean.sh out of sync
+    missing turbo.json
+    drift clean should start with "sh clean.sh"
+    dep react should be "latest" or "^major"
+    duplicate ai already provided by workspace dep
+    forbidden npm found, use bun only
+    ci failed 2026-04-02
+    deploy vercel deployment failed
+checks:
+  git status (auto-pulls clean repos)
+  config drift (synced files match source)
+  missing infra (turbo.json, tsconfig.json, ci.yml)
+  root package.json (private, packageManager, hooks, sherif, prepare, clean)
+  tsconfig extends lintmax/tsconfig, no include
+  vercel.json installCommand is bun i
+  vercel deployment status
+  layout conventions (suppressHydrationWarning, antialiased, tracking, min-h-screen, font-sans, metadata, fonts.ts, providers.tsx, global.css, arrow function export, no RootLayout, no Provider inline)
+  page conventions (arrow function export)
+  next.config (reactStrictMode, no redundant postcss in apps)
+  app tsconfig (extends lintmax, no include)
+  banned packages (817 entries), bun globals, @a/ui deep imports
+  deps on latest or ^major, no duplicates across workspaces
+  no npm/yarn/pnpm in scripts or lockfiles
+  turbo scripts have --output-logs=errors-only
+  published packages have type:module, exports, files, license, repository
+  workspace devDependencies hoisted to root
+  no nested .gitignore, no postcss.config.mjs, no @ts-nocheck
+  no bun.lock tracked in git, no redundant clean scripts
+  ci status via github api`;
+//#endregion
+export { guide as t };

package/dist/guide.d.mts

@@ -0,0 +1,2 @@
+import { t as guide } from "./guide-BS7-RqpH.mjs";
+export { guide };

package/dist/guide.mjs

@@ -0,0 +1,2 @@
+import { t as guide } from "./guide-CifUmtQN.mjs";
+export { guide };

package/dist/ignores-BBl55eUM.mjs

@@ -0,0 +1,37 @@
+import { f as projectName, u as isInsideProject } from "./utils-CpkOMuQN.mjs";
+import { t as discover } from "./discover-d8ENQC1K.mjs";
+import { $ } from "bun";
+//#region src/ignores.ts
+/** biome-ignore-all lint/performance/noAwaitInLoops: sequential project scan */
+const ignores = async (all = false) => {
+	let projects;
+	if (all) {
+		const { consumers, self, cnsync } = await discover();
+		projects = [
+			self,
+			cnsync,
+			...consumers
+		];
+	} else {
+		const projectPath = await isInsideProject();
+		if (projectPath) projects = [{
+			name: projectName(projectPath),
+			path: projectPath
+		}];
+		else {
+			const { consumers, self, cnsync } = await discover();
+			projects = [
+				self,
+				cnsync,
+				...consumers
+			];
+		}
+	}
+	for (const project of projects) {
+		console.log(`${project.name}:`);
+		await $`bunx lintmax@latest ignores`.cwd(project.path).nothrow();
+		console.log();
+	}
+};
+//#endregion
+export { ignores };

package/dist/index.d.mts

@@ -0,0 +1,83 @@
+import { t as guide } from "./guide-BS7-RqpH.mjs";
+import { A as createEvent, C as timeAgo, D as WatchEvent, E as WATCH_STEPS, O as WatchStatus, S as tickProjects, T as WATCH_STATUSES, _ 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, k as WatchStep, 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, w as CreateEventArgs, x as sparkline, y as smoothBar } from "./watch-state-DIMHiLr5.mjs";
+
+//#region src/types.d.ts
+interface Issue {
+  detail: string;
+  type: IssueType;
+}
+type IssueType = 'bun' | 'check' | 'ci' | 'dep' | 'deploy' | 'drift' | 'duplicate' | 'error' | 'file' | 'forbidden' | 'git' | 'info' | 'lintmax' | 'missing' | 'synced' | 'unused' | 'up.sh';
+interface PackageJson {
+  bin?: Record<string, string> | string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  exports?: Record<string, Record<string, string> | string>;
+  files?: string[];
+  license?: string;
+  main?: string;
+  name?: string;
+  packageManager?: string;
+  peerDependencies?: Record<string, string>;
+  private?: boolean;
+  repository?: {
+    directory?: string;
+    type?: string;
+    url?: string;
+  };
+  scripts?: Record<string, string>;
+  'simple-git-hooks'?: Record<string, string>;
+  trustedDependencies?: string[];
+  type?: string;
+  workspaces?: string[];
+}
+//#endregion
+//#region src/audit.d.ts
+declare const audit: (projectPath: string) => Promise<Issue[]>;
+//#endregion
+//#region src/check-cache.d.ts
+interface CheckResult {
+  at: string;
+  commit: string;
+  pass: boolean;
+  summary?: string;
+  violations: number;
+}
+declare const readCheckResult: (projectPath: string) => CheckResult | undefined;
+//#endregion
+//#region src/constants.d.ts
+declare const TSDOWN_BASE: {
+  clean: boolean;
+  deps: {
+    neverBundle: string[];
+  };
+  dts: boolean;
+  format: "esm";
+  outDir: string;
+};
+//#endregion
+//#region src/discover.d.ts
+interface Project {
+  isCnsync: boolean;
+  isSelf: boolean;
+  name: string;
+  path: string;
+}
+declare const discover: (searchRoot?: string, excludes?: readonly string[]) => Promise<{
+  cnsync: Project;
+  consumers: Project[];
+  self: Project;
+}>;
+//#endregion
+//#region src/fix.d.ts
+declare const fix: (all?: boolean, excludes?: readonly string[]) => Promise<void>;
+//#endregion
+//#region src/infer.d.ts
+declare const inferRules: (projectPath: string, rulesDir?: string) => Promise<string[]>;
+//#endregion
+//#region src/status.d.ts
+declare const status: (swiftbar?: boolean, all?: boolean, excludes?: readonly string[]) => Promise<void>;
+//#endregion
+//#region src/watch-emitter.d.ts
+declare const SOCKET_PATH: string;
+//#endregion
+export { type CheckResult, type CreateEventArgs, DISPLAY_STEPS, type DerivedStats, IDLE_FALLBACK, type Issue, type IssueType, type PackageJson, type ProjectInfo, type ProjectState, RESET_DELAY, type RunAction, type RunState, SOCKET_PATH, STATUS_ORDER, STEP_COUNT, STEP_LABELS, WATCH_STATUSES, WATCH_STEPS, type WatchEvent, type WatchStatus, type WatchStep, audit, createEvent, createInitState, deriveStats, discover, fix, formatTime, guide, inferRules, nextProjectState, progressDots, readCheckResult, runReducer, smoothBar, sortByStatus, sparkline, status, tickProjects, timeAgo, TSDOWN_BASE as tsdownBase };

package/dist/index.mjs

@@ -0,0 +1,11 @@
+import { L as TSDOWN_BASE } from "./utils-CpkOMuQN.mjs";
+import { t as audit } from "./audit-oQQfgtxr.mjs";
+import { o as readCheckResult, t as SOCKET_PATH } from "./watch-emitter-uTmZ3oQd.mjs";
+import { t as discover } from "./discover-d8ENQC1K.mjs";
+import { t as fix } from "./fix-BcMN_cuG.mjs";
+import { l as inferRules } from "./sync-DN1rgN3P.mjs";
+import { n as WATCH_STEPS, r as createEvent, t as WATCH_STATUSES } from "./watch-types-BzSNCGb2.mjs";
+import { t as guide } from "./guide-CifUmtQN.mjs";
+import { t as status } from "./status-CzCNkG58.mjs";
+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, 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, RESET_DELAY, SOCKET_PATH, STATUS_ORDER, STEP_COUNT, STEP_LABELS, WATCH_STATUSES, WATCH_STEPS, audit, createEvent, createInitState, deriveStats, discover, fix, formatTime, guide, inferRules, nextProjectState, progressDots, readCheckResult, runReducer, smoothBar, sortByStatus, sparkline, status, tickProjects, timeAgo, TSDOWN_BASE as tsdownBase };

package/dist/init-C-073mRX.mjs

@@ -0,0 +1,120 @@
+import { a as getBunVersion } from "./utils-CpkOMuQN.mjs";
+import { t as discover } from "./discover-d8ENQC1K.mjs";
+import { t as syncClaudeMd } from "./sync-DN1rgN3P.mjs";
+import { $, file, write } from "bun";
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+//#region src/init.ts
+const SKIP = new Set([
+	".git",
+	".next",
+	".turbo",
+	".vercel",
+	"bun.lock",
+	"CLAUDE.md",
+	"dist",
+	"LEARNING.md",
+	"node_modules",
+	"PLAN.md",
+	"PROGRESS.md",
+	"prompts",
+	"README.md",
+	"RULES.md",
+	"vercel.json"
+]);
+const REMOVE_PATHS = [
+	"apps/web/src/lib/router.ts",
+	"apps/web/src/lib/socket.ts",
+	"apps/web/src/lib/auth.ts",
+	"apps/web/src/lib/client.ts",
+	"apps/web/src/app/api",
+	"apps/web/src/app/auth",
+	"apps/web/src/tests",
+	"apps/docs/src/app/llms-full.txt",
+	"apps/docs/src/app/llms.txt",
+	"apps/docs/src/app/api"
+];
+const copyTree = (src, dst, skipExtra) => {
+	for (const entry of readdirSync(src)) if (!(SKIP.has(entry) || skipExtra?.has(entry))) {
+		const s = join(src, entry);
+		const d = join(dst, entry);
+		if (statSync(s).isDirectory()) {
+			mkdirSync(d, { recursive: true });
+			copyTree(s, d);
+		} else cpSync(s, d);
+	}
+};
+const copyTemplateDir = async (tplDir, dstDir, projectName) => {
+	await Promise.all(readdirSync(tplDir).map(async (entry) => {
+		const s = join(tplDir, entry);
+		const d = join(dstDir, entry);
+		if (statSync(s).isDirectory()) {
+			mkdirSync(d, { recursive: true });
+			await copyTemplateDir(s, d, projectName);
+		} else {
+			const content = await file(s).text();
+			mkdirSync(dirname(d), { recursive: true });
+			await write(d, content.replaceAll("__NAME__", projectName));
+		}
+	}));
+};
+const patchFile = async (path, replacements) => {
+	if (!existsSync(path)) return;
+	let content = await file(path).text();
+	for (const [from, to] of replacements) content = content.replaceAll(from, to);
+	await write(path, content);
+};
+const templateDir = join(dirname(new URL(import.meta.url).pathname), "templates");
+const init = async (name) => {
+	const projectName = basename(resolve(process.cwd(), name));
+	const dir = resolve(process.cwd(), name);
+	if (existsSync(dir)) {
+		console.log(`${dir} already exists`);
+		return;
+	}
+	const { self } = await discover();
+	const src = self.path;
+	console.log(`scaffolding ${projectName} from ${src}...`);
+	mkdirSync(dir, { recursive: true });
+	copyTree(src, dir, new Set(["packages"]));
+	for (const p of REMOVE_PATHS) rmSync(join(dir, p), {
+		force: true,
+		recursive: true
+	});
+	rmSync(join(dir, "packages"), {
+		force: true,
+		recursive: true
+	});
+	rmSync(join(dir, "apps", "docs", "content", "rules"), {
+		force: true,
+		recursive: true
+	});
+	mkdirSync(join(dir, "apps", "docs", "content", "docs"), { recursive: true });
+	await Promise.all([
+		copyTemplateDir(join(templateDir, "cli"), join(dir, "packages", "cli"), projectName),
+		copyTemplateDir(join(templateDir, "lib"), join(dir, "packages", "lib"), projectName),
+		copyTemplateDir(join(templateDir, "web"), join(dir, "apps", "web"), projectName),
+		copyTemplateDir(join(templateDir, "docs"), join(dir, "apps", "docs"), projectName)
+	]);
+	const bunVersion = await getBunVersion();
+	const rootPkgText = (await file(join(templateDir, "root-package.txt")).text()).replace("__PACKAGE_MANAGER__", `bun@${bunVersion}`).replace("__NAME__", `${projectName}-workspace`);
+	await Promise.all([
+		write(join(dir, "package.json"), rootPkgText),
+		patchFile(join(dir, "apps", "docs", "src", "lib", "shared.ts"), [["pm4ai", projectName]]),
+		patchFile(join(dir, "apps", "docs", "src", "lib", "layout.shared.tsx"), [["pm4ai", projectName]]),
+		patchFile(join(dir, "apps", "web", "src", "app", "layout.tsx"), [["pm4ai dashboard", projectName]])
+	]);
+	await syncClaudeMd(src, dir);
+	const bookInstall = join(homedir(), "book", "install.sh");
+	if (existsSync(bookInstall)) await $`sh ${bookInstall} ${dir}`.quiet().nothrow();
+	await $`git init`.cwd(dir).quiet();
+	await $`git add -A`.cwd(dir).quiet();
+	await $`git -c user.name=pm4ai -c user.email=pm4ai commit -m "init: scaffold from pm4ai"`.cwd(dir).quiet().nothrow();
+	console.log(`\ncreated ${projectName}/`);
+	console.log(`\n  cd ${projectName}`);
+	console.log("  bun i");
+	console.log("  bun dev");
+};
+//#endregion
+export { init };

package/dist/list-QdJPgkEO.mjs

@@ -0,0 +1,31 @@
+import { t as discover } from "./discover-d8ENQC1K.mjs";
+import { $ } from "bun";
+//#region src/list.ts
+const AHEAD_RE = /\+(?<n>\d+)/u;
+const BEHIND_RE = /-(?<n>\d+)/u;
+const gitStatus = async (path) => {
+	const out = (await $`git -C ${path} status -sb --porcelain=v2 --branch`.quiet().nothrow()).stdout.toString();
+	const aheadMatch = AHEAD_RE.exec(out);
+	const behindMatch = BEHIND_RE.exec(out);
+	const dirty = out.split("\n").some((l) => l.startsWith("1 ") || l.startsWith("2 ") || l.startsWith("?"));
+	return {
+		ahead: aheadMatch ? Number(aheadMatch.groups?.n) : 0,
+		behind: behindMatch ? Number(behindMatch.groups?.n) : 0,
+		dirty
+	};
+};
+const list = async (excludes = [], searchRoot, write = (row) => console.log(row)) => {
+	const { consumers } = await discover(searchRoot, excludes);
+	const rows = await Promise.all(consumers.map(async (c) => {
+		const g = await gitStatus(c.path);
+		const flags = [
+			g.dirty ? "dirty" : "clean",
+			g.behind ? `behind:${g.behind}` : "",
+			g.ahead ? `ahead:${g.ahead}` : ""
+		].filter(Boolean).join(",");
+		return `${c.path}\t${flags}`;
+	}));
+	for (const r of rows.toSorted()) write(r);
+};
+//#endregion
+export { list };

package/dist/package-NpIViQjo.mjs

@@ -0,0 +1,4 @@
+//#region package.json
+var version = "0.0.73";
+//#endregion
+export { version as t };