pm4ai 0.0.73

package/README.md

@@ -0,0 +1,34 @@
+# pm4ai
+
+Agent-first anti-slop project management for TypeScript monorepos.
+
+One source of truth. Zero manual maintenance.
+
+## Quick Start
+
+```sh
+bunx pm4ai@latest status       # check current project
+bunx pm4ai@latest fix          # sync + maintain current project
+bunx pm4ai@latest status --all # check all projects
+bunx pm4ai@latest fix --all    # sync + maintain all projects
+bunx pm4ai@latest init app     # scaffold a new project
+bunx pm4ai@latest setup        # menubar + daily auto-run
+```
+
+## How It Works
+
+pm4ai is context-aware. Inside a project, it operates on that project only. Use `--all` to scan everything.
+
+**`pm4ai status`** checks the current project — git status, config drift, dep audit, CI status, Vercel deployments, background lint check — and reports only issues.
+
+**`pm4ai fix`** requires clean git state (no uncommitted changes, up to date with remote). Syncs dotfiles, generates CLAUDE.md from rules, copies readonly/ui, runs maintenance (`sh up.sh`). Shows file change summary after completion.
+
+**`pm4ai init`** scaffolds a new project with turbo, lintmax, sherif, simple-git-hooks, CI workflow — everything correct from day one.
+
+**`pm4ai setup`** installs a SwiftBar menubar plugin (hourly refresh) and a launchd agent (daily auto-fix).
+
+## For Agents
+
+Full docs: `curl https://pm4ai.vercel.app/llms-full.txt`
+
+Start prompts for Claude Code sessions: [PM session](prompts/pm.md) · [Project session](prompts/project.md)

package/dist/audit-oQQfgtxr.mjs

@@ -0,0 +1,287 @@
+import { O as FORBIDDEN_PM_PREFIXES, P as REQUIRED_ROOT_DEVDEPS, R as TURBO_FLAG, c as gitCleanRe, d as isSkippedPath, k as LINTMAX_PKG, n as collectWorkspacePackages, r as debug, t as buildPkgDepMap } from "./utils-CpkOMuQN.mjs";
+import { a as npmVersionSchema, n as ghReleaseSchema, o as safeParse } from "./schemas-Dsbtf6P2.mjs";
+import { $ } from "bun";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region src/types.ts
+const DEP_FIELDS = ["dependencies", "devDependencies"];
+const ALL_DEP_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies"
+];
+//#endregion
+//#region src/audit.ts
+const latestNpmVersionCache = /* @__PURE__ */ new Map();
+const fetchNpmVersion = async (pkg) => {
+	const url = `https://registry.npmjs.org/${pkg}/latest`;
+	const res = await fetch(url).catch(() => void 0);
+	if (!res?.ok) {
+		debug("fetch failed:", url);
+		return;
+	}
+	return safeParse(npmVersionSchema, await res.json())?.version;
+};
+const getLatestNpmVersion = async (pkg) => {
+	const cached = latestNpmVersionCache.get(pkg);
+	if (cached) return cached;
+	const p = fetchNpmVersion(pkg);
+	latestNpmVersionCache.set(pkg, p);
+	const v = await p;
+	if (!v) latestNpmVersionCache.delete(pkg);
+	return v;
+};
+let latestBunVersionCache;
+const fetchBunVersion = async () => {
+	const url = "https://api.github.com/repos/oven-sh/bun/releases/latest";
+	const res = await fetch(url).catch(() => void 0);
+	if (!res?.ok) {
+		debug("fetch failed:", url);
+		return;
+	}
+	return safeParse(ghReleaseSchema, await res.json())?.tag_name.replace("bun-v", "");
+};
+const getLatestBunVersion = async () => {
+	if (latestBunVersionCache) return latestBunVersionCache;
+	latestBunVersionCache = fetchBunVersion();
+	const v = await latestBunVersionCache;
+	if (!v) latestBunVersionCache = void 0;
+	return v;
+};
+const isPublishedPkg = (pkg) => !pkg.private && Boolean(pkg.name) && Boolean(pkg.exports ?? pkg.main ?? pkg.bin);
+const getDepsFromPkg = (pkg) => {
+	const result = /* @__PURE__ */ new Map();
+	for (const field of DEP_FIELDS) {
+		const deps = pkg[field];
+		if (deps) for (const [n, v] of Object.entries(deps)) result.set(n, v);
+	}
+	return result;
+};
+const checkPackageConventions = (pkgs, projectPath) => {
+	const issues = [];
+	const filtered = pkgs.filter((p) => !isSkippedPath(p.path) && p.path !== join(projectPath, "package.json"));
+	for (const { path: pkgPath, pkg } of filtered) {
+		const shortPath = pkgPath.replace(`${projectPath}/`, "");
+		if (isPublishedPkg(pkg)) {
+			if (pkg.type !== "module") issues.push({
+				detail: `${shortPath} should have "type": "module"`,
+				type: "drift"
+			});
+			if (!pkg.files) issues.push({
+				detail: `${shortPath} missing "files" field`,
+				type: "drift"
+			});
+			if (!pkg.license) issues.push({
+				detail: `${shortPath} missing "license" field`,
+				type: "drift"
+			});
+			if (!pkg.repository) issues.push({
+				detail: `${shortPath} missing "repository" field`,
+				type: "drift"
+			});
+		}
+		const devDeps = pkg.devDependencies;
+		if ((devDeps ? Object.entries(devDeps).filter(([, v]) => !v.startsWith("workspace:")) : []).length > 0) issues.push({
+			detail: `${shortPath} devDependencies should be hoisted to root`,
+			type: "drift"
+		});
+	}
+	return issues;
+};
+const checkDuplicates = (pkgs, projectPath) => {
+	const issues = [];
+	const pkgDepsByName = buildPkgDepMap(pkgs);
+	const filtered = pkgs.filter((p) => !isSkippedPath(p.path));
+	for (const { path: pkgPath, pkg } of filtered) {
+		const shortPath = pkgPath.replace(`${projectPath}/`, "");
+		const allDeps = [...getDepsFromPkg(pkg)];
+		const wsDeps = allDeps.filter(([, v]) => v.startsWith("workspace:")).map(([n]) => n);
+		const ownDeps = new Set(allDeps.filter(([, v]) => !v.startsWith("workspace:")).map(([n]) => n));
+		const providedByWs = /* @__PURE__ */ new Set();
+		for (const ws of wsDeps) for (const d of pkgDepsByName.get(ws) ?? []) providedByWs.add(d);
+		const isRoot = pkgPath === join(projectPath, "package.json");
+		const isApp = shortPath.startsWith("apps/");
+		const duplicated = [...ownDeps].filter((d) => providedByWs.has(d) && !(isRoot && REQUIRED_ROOT_DEVDEPS.includes(d)) && !isApp);
+		for (const dep of duplicated) issues.push({
+			detail: `${dep} in ${shortPath} already provided by workspace dep`,
+			type: "duplicate"
+		});
+	}
+	return issues;
+};
+const usesForbidden = (cmd) => FORBIDDEN_PM_PREFIXES.some((p) => cmd.startsWith(p) || cmd.includes(` && ${p}`) || cmd.includes(` || ${p}`));
+const turboRe = /\bturbo\b/u;
+const checkScripts = (pkgs, projectPath) => {
+	const issues = [];
+	const rootPkgPath = join(projectPath, "package.json");
+	const filtered = pkgs.filter((p) => !isSkippedPath(p.path));
+	for (const { path: pkgPath, pkg } of filtered) {
+		const shortPath = pkgPath.replace(`${projectPath}/`, "");
+		const isRoot = pkgPath === rootPkgPath;
+		const scripts = Object.entries(pkg.scripts ?? {});
+		for (const [script, cmd] of scripts) {
+			if (usesForbidden(cmd)) issues.push({
+				detail: `"${script}" uses non-bun pm in ${shortPath}`,
+				type: "forbidden"
+			});
+			if (isRoot && turboRe.test(cmd) && !cmd.includes("--output-logs=errors-only") && !script.startsWith("dev")) issues.push({
+				detail: `"${script}" missing ${TURBO_FLAG}`,
+				type: "drift"
+			});
+			if (isRoot && turboRe.test(cmd) && cmd.includes("--output-logs=errors-only") && !script.startsWith("dev") && !cmd.includes("WARNING|Could not resolve workspaces|missing field|Turborepo will still function")) issues.push({
+				detail: `"${script}" missing turbo workspace warning filter`,
+				type: "drift"
+			});
+		}
+		if (!isRoot && scripts.some(([s]) => s === "clean")) issues.push({
+			detail: `${shortPath} has redundant "clean" script, use root clean.sh`,
+			type: "drift"
+		});
+	}
+	return issues;
+};
+const checkRootScripts = (rootPkg) => {
+	const issues = [];
+	const scripts = rootPkg.scripts ?? {};
+	if (!scripts.build?.includes("turbo")) issues.push({
+		detail: "root \"build\" should use turbo",
+		type: "drift"
+	});
+	if (scripts.check && !scripts.check.includes("lintmax") && !scripts.check.includes("cli.js check")) issues.push({
+		detail: "root \"check\" should include \"lintmax check\"",
+		type: "drift"
+	});
+	if (scripts.fix && !scripts.fix.endsWith(`lintmax fix`) && !scripts.fix.endsWith("cli.js fix") && !scripts.fix.endsWith("cli.mjs fix")) issues.push({
+		detail: "root \"fix\" should end with \"lintmax fix\"",
+		type: "drift"
+	});
+	return issues;
+};
+const checkRootWorkspacesAndDevDeps = (rootPkg) => {
+	const issues = [];
+	if (!rootPkg.workspaces || rootPkg.workspaces.length === 0) issues.push({
+		detail: "root missing \"workspaces\" field",
+		type: "missing"
+	});
+	const allDeps = {
+		...rootPkg.dependencies,
+		...rootPkg.devDependencies
+	};
+	for (const dep of REQUIRED_ROOT_DEVDEPS) if (!allDeps[dep]) issues.push({
+		detail: `root missing "${dep}" in devDependencies`,
+		type: "missing"
+	});
+	return issues;
+};
+const checkTrustedDeps = (rootPkg, requiredTrusted) => {
+	const issues = [];
+	const trusted = rootPkg.trustedDependencies ?? [];
+	for (const dep of requiredTrusted ?? []) if (!trusted.includes(dep)) issues.push({
+		detail: `root missing "${dep}" in trustedDependencies`,
+		type: "missing"
+	});
+	return issues;
+};
+const checkPublishedPkgConventions = (pkgs, projectPath) => {
+	const issues = [];
+	const published = pkgs.filter((p) => isPublishedPkg(p.pkg));
+	for (const { path: pkgPath, pkg } of published) {
+		const shortPath = pkgPath.replace(`${projectPath}/`, "");
+		if (!pkg.scripts?.postpublish) issues.push({
+			detail: `${shortPath} published but missing "postpublish" cleanup`,
+			type: "drift"
+		});
+		if (pkg.scripts?.build && pkg.scripts.build !== "tsdown") issues.push({
+			detail: `${shortPath} build must be exactly "tsdown"`,
+			type: "drift"
+		});
+		if (pkg.scripts?.build && pkg.scripts.prepublishOnly !== "bun run build") issues.push({
+			detail: `${shortPath} missing "prepublishOnly": "bun run build" — stale dist will ship`,
+			type: "drift"
+		});
+		if (!existsSync(join(dirname(pkgPath), "tsdown.config.ts"))) issues.push({
+			detail: `${shortPath} missing tsdown.config.ts`,
+			type: "missing"
+		});
+	}
+	return issues;
+};
+const checkAppPackages = (pkgs, projectPath) => {
+	const issues = [];
+	for (const { path: pkgPath, pkg } of pkgs) {
+		const rel = pkgPath.replace(`${projectPath}/`, "");
+		if (rel.startsWith("apps/") && !pkg.private) issues.push({
+			detail: `${rel} should be private`,
+			type: "drift"
+		});
+	}
+	return issues;
+};
+const checkSubPkgScripts = (pkgs, projectPath) => {
+	const issues = [];
+	const rootPkgPath = join(projectPath, "package.json");
+	const filtered = pkgs.filter((p) => !isSkippedPath(p.path) && p.path !== rootPkgPath);
+	for (const { path: pkgPath, pkg } of filtered) {
+		const shortPath = pkgPath.replace(`${projectPath}/`, "");
+		for (const [script, cmd] of Object.entries(pkg.scripts ?? {})) if (gitCleanRe.test(cmd)) issues.push({
+			detail: `"${script}" uses git clean in ${shortPath}, use rm -rf`,
+			type: "forbidden"
+		});
+	}
+	return issues;
+};
+const audit = async (projectPath) => {
+	const issues = [];
+	const pkgs = (await collectWorkspacePackages(projectPath)).map((e) => ({
+		path: e.path,
+		pkg: e.pkg
+	}));
+	const rootPkg = pkgs[0]?.pkg;
+	const bunVersion = rootPkg?.packageManager?.replace("bun@", "");
+	if (bunVersion) {
+		const latest = await getLatestBunVersion();
+		if (latest && bunVersion !== latest) issues.push({
+			detail: `${bunVersion} behind latest ${latest}`,
+			type: "bun"
+		});
+	}
+	const lintmaxVersion = getDepsFromPkg(rootPkg ?? {}).get(LINTMAX_PKG);
+	if (lintmaxVersion && !lintmaxVersion.startsWith("workspace:")) {
+		const lintmaxLatest = await getLatestNpmVersion(LINTMAX_PKG);
+		if (lintmaxLatest) {
+			const resolved = (await $`bun why ${LINTMAX_PKG}`.cwd(projectPath).quiet().nothrow()).stdout.toString().trim();
+			if (resolved && !resolved.includes(lintmaxLatest)) issues.push({
+				detail: `resolved version behind latest ${lintmaxLatest}`,
+				type: LINTMAX_PKG
+			});
+		}
+	}
+	if (rootPkg) {
+		issues.push(...checkRootScripts(rootPkg));
+		issues.push(...checkRootWorkspacesAndDevDeps(rootPkg));
+		const selfPkgPath = join(import.meta.dirname, "..", "..", "..", "package.json");
+		const selfPkg = existsSync(selfPkgPath) ? JSON.parse(readFileSync(selfPkgPath, "utf8")) : {};
+		issues.push(...checkTrustedDeps(rootPkg, selfPkg.trustedDependencies ?? []));
+	}
+	issues.push(...checkPackageConventions(pkgs, projectPath));
+	issues.push(...checkDuplicates(pkgs, projectPath));
+	issues.push(...checkScripts(pkgs, projectPath));
+	issues.push(...checkPublishedPkgConventions(pkgs, projectPath));
+	issues.push(...checkAppPackages(pkgs, projectPath));
+	issues.push(...checkSubPkgScripts(pkgs, projectPath));
+	const publishedPkgs = pkgs.filter((p) => isPublishedPkg(p.pkg));
+	await Promise.all(publishedPkgs.map(async (p) => {
+		const r = await $`bun pm view ${p.pkg.name} versions --json`.quiet().nothrow();
+		if (r.exitCode !== 0) return;
+		try {
+			const parsed = JSON.parse(r.stdout.toString());
+			if (Array.isArray(parsed) && parsed.length > 1) issues.push({
+				detail: `${p.pkg.name} has ${parsed.length} versions published, run cleanup`,
+				type: "drift"
+			});
+		} catch {}
+	}));
+	return issues;
+};
+//#endregion
+export { DEP_FIELDS as i, isPublishedPkg as n, ALL_DEP_FIELDS as r, audit as t };

package/dist/cleanup-M-ALxTqh.mjs

@@ -0,0 +1,35 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+//#region src/cleanup.ts
+const cleanup = () => {
+	const pkgPath = join(process.cwd(), "package.json");
+	const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+	if (!(pkg.name && pkg.version)) {
+		console.error("package.json missing name or version");
+		process.exitCode = 1;
+		return;
+	}
+	const result = spawnSync("npm", [
+		"view",
+		pkg.name,
+		"versions",
+		"--json"
+	], { encoding: "utf8" });
+	if (result.status !== 0) {
+		console.log(`${pkg.name}: first publish, nothing to clean`);
+		return;
+	}
+	const versions = JSON.parse(result.stdout);
+	const old = (Array.isArray(versions) ? versions : [versions]).filter((v) => v !== pkg.version);
+	if (old.length === 0) {
+		console.log(`${pkg.name}: no old versions`);
+		return;
+	}
+	for (const v of old) if (spawnSync("npm", ["unpublish", `${pkg.name}@${v}`], {
+		encoding: "utf8",
+		stdio: "inherit"
+	}).status === 0) console.log(`${pkg.name}@${v} unpublished`);
+};
+//#endregion
+export { cleanup };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env bun
+import { _ as setVerbose } from "./utils-CpkOMuQN.mjs";
+import { t as guide } from "./guide-CifUmtQN.mjs";
+import { t as version } from "./package-NpIViQjo.mjs";
+import { $ } from "bun";
+//#region src/preflight.ts
+const REQUIRED = ["rg", "git"];
+const OPTIONAL = ["gh"];
+const check = async (name) => {
+	return (await $`which ${name}`.quiet().nothrow()).exitCode === 0;
+};
+const preflight = async () => {
+	const [requiredResults, optionalResults] = await Promise.all([Promise.all(REQUIRED.map(async (name) => ({
+		found: await check(name),
+		name
+	}))), Promise.all(OPTIONAL.map(async (name) => ({
+		found: await check(name),
+		name
+	})))]);
+	const missingRequired = requiredResults.filter((r) => !r.found);
+	const missingOptional = optionalResults.filter((r) => !r.found);
+	if (missingRequired.length > 0) {
+		console.log("missing required:");
+		for (const r of missingRequired) console.log(`  ${r.name}`);
+	}
+	if (missingOptional.length > 0) {
+		console.log("missing optional (some checks skipped):");
+		for (const r of missingOptional) console.log(`  ${r.name}`);
+	}
+	return missingRequired.length === 0;
+};
+//#endregion
+//#region src/cli.ts
+const args = process.argv.slice(2);
+const flags = new Set(args.filter((a) => a.startsWith("-")));
+const positional = args.filter((a) => !a.startsWith("-"));
+const command = positional[0];
+const excludes = [...flags].filter((f) => f.startsWith("--exclude=")).flatMap((f) => f.slice(10).split(",")).map((s) => s.trim()).filter(Boolean);
+if (flags.has("--verbose")) setVerbose(true);
+if (flags.has("--version") || flags.has("-v")) console.log(version);
+else if (!command) console.log(guide);
+else if (command === "init") {
+	const name = positional[1];
+	if (name) {
+		const { init } = await import("./init-C-073mRX.mjs");
+		await init(name);
+	} else console.log("usage: pm4ai init <name>");
+} else if (command === "setup") {
+	const { setup } = await import("./setup-BPuE4oWT.mjs");
+	await setup();
+} else {
+	if (!await preflight()) throw new Error("missing required tools");
+	if (command === "status") {
+		const { status } = await import("./status-ByiuW1iF.mjs");
+		await status(flags.has("--swiftbar"), flags.has("--all"), excludes);
+	} else if (command === "fix") {
+		const { fix } = await import("./fix-DvtItv_V.mjs");
+		await fix(flags.has("--all"), excludes);
+	} else if (command === "watch") {
+		const { watch } = await import("./watch-D4OSFClu.mjs");
+		await watch(flags.has("--json"));
+	} else if (command === "dashboard") {
+		const { dashboard } = await import("./dashboard-DVRNZGun.mjs");
+		await dashboard();
+	} else if (command === "ignores") {
+		const { ignores } = await import("./ignores-BBl55eUM.mjs");
+		await ignores(flags.has("--all"));
+	} else if (command === "cleanup") {
+		const { cleanup } = await import("./cleanup-M-ALxTqh.mjs");
+		cleanup();
+	} else if (command === "list") {
+		const { list } = await import("./list-QdJPgkEO.mjs");
+		await list(excludes);
+	} else console.log(guide);
+}
+//#endregion
+export {};

package/dist/dashboard-DVRNZGun.mjs

@@ -0,0 +1,39 @@
+import { t as discover } from "./discover-d8ENQC1K.mjs";
+import { existsSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+//#region src/dashboard.ts
+const dashboard = async () => {
+	const { self } = await discover();
+	const dashboardDir = join(self.path, "apps", "web");
+	if (!existsSync(dashboardDir)) {
+		console.log("dashboard app not found at", dashboardDir);
+		console.log("run from pm4ai monorepo or ensure apps/web exists");
+		return;
+	}
+	const token = randomUUID();
+	const tokenFile = join(dashboardDir, ".auth-token");
+	writeFileSync(tokenFile, token);
+	const url = `http://localhost:4200/auth/${token}`;
+	console.log(`dashboard: ${url}`);
+	console.log("(token is one-time use — copy URL if port-forwarding)");
+	const proc = spawn("bun", ["run", "dev"], {
+		cwd: dashboardDir,
+		stdio: "inherit"
+	});
+	setTimeout(() => {
+		if (process.platform === "darwin") spawn("open", [url], { stdio: "ignore" }).unref();
+	}, 2e3);
+	await new Promise((resolve, reject) => {
+		proc.on("close", (code) => {
+			try {
+				unlinkSync(tokenFile);
+			} catch {}
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`dashboard exited with code ${code}`));
+		});
+	});
+};
+//#endregion
+export { dashboard };

package/dist/discover-d8ENQC1K.mjs

@@ -0,0 +1,172 @@
+import { M as PKG_NAME, f as projectName, r as debug, x as CONFIG_DIR } from "./utils-CpkOMuQN.mjs";
+import { $, file } from "bun";
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+//#region src/discover.ts
+const hasDirInside = (dir, sub) => existsSync(join(dir, sub));
+const hasLintmaxDep = async (dir) => {
+	const pkgFile = file(join(dir, "package.json"));
+	if (!await pkgFile.exists()) return false;
+	try {
+		const pkg = await pkgFile.json();
+		return Boolean(pkg.dependencies?.["lintmax"] ?? pkg.devDependencies?.["lintmax"] ?? pkg.peerDependencies?.["lintmax"]);
+	} catch {
+		return false;
+	}
+};
+const isCnsyncRepo = async (dir) => {
+	if (!hasDirInside(dir, "readonly/ui")) return false;
+	return (await $`git remote get-url origin`.cwd(dir).quiet().nothrow()).stdout.toString().trim().includes(`1qh/cnsync`);
+};
+const cloneIfMissing = async (repo, dest) => {
+	if (existsSync(dest)) return dest;
+	debug("cloning", repo, "to", dest);
+	mkdirSync(dirname(dest), { recursive: true });
+	await $`git clone https://github.com/${"1qh"}/${repo}.git ${dest}`.quiet().nothrow();
+	return dest;
+};
+const rgExcludes = [
+	"-g",
+	"!**/node_modules/**",
+	"-g",
+	"!**/.cache/**",
+	"-g",
+	"!**/.Trash/**",
+	"-g",
+	"!**/Library/**",
+	"-g",
+	"!**/Applications/**",
+	"-g",
+	"!**/.local/**",
+	"-g",
+	"!**/.npm/**",
+	"-g",
+	"!**/.bun/**",
+	"-g",
+	"!**/.docker/**",
+	"-g",
+	"!**/iCloud*/**",
+	"-g",
+	"!**/.git/**"
+];
+const discover = async (searchRoot, excludes = []) => {
+	const home = searchRoot ?? homedir();
+	const stdout = (await $`rg --files ${home} -g turbo.json -g turbo.jsonc ${rgExcludes}`.quiet().nothrow()).stdout.toString().trim();
+	if (!stdout) debug("rg not found or returned empty");
+	const found = stdout.split("\n").filter(Boolean);
+	const allDirs = [...new Set(found.map((f) => dirname(f)))].toSorted();
+	const turboRoots = allDirs.filter((dir) => !allDirs.some((other) => other !== dir && dir.startsWith(`${other}/`)));
+	const projects = (await Promise.all(turboRoots.map(async (dir) => {
+		if (!await hasLintmaxDep(dir)) return null;
+		const name = projectName(dir);
+		const isSelf = name === "pm4ai-monorepo" || name === PKG_NAME;
+		if (!isSelf && (excludes.includes(name) || excludes.includes(dir))) return null;
+		return {
+			isCnsync: await isCnsyncRepo(dir),
+			isSelf,
+			name,
+			path: dir
+		};
+	}))).filter((p) => p !== null);
+	let self = projects.find((p) => p.isSelf);
+	let cnsync = projects.find((p) => p.isCnsync);
+	const reposDir = join(home, CONFIG_DIR, "repos");
+	if (!self) {
+		const dest = join(reposDir, PKG_NAME);
+		await cloneIfMissing(PKG_NAME, dest);
+		self = {
+			isCnsync: false,
+			isSelf: true,
+			name: PKG_NAME,
+			path: dest
+		};
+	}
+	if (!cnsync) {
+		const dest = join(reposDir, "cnsync");
+		await cloneIfMissing("cnsync", dest);
+		cnsync = {
+			isCnsync: true,
+			isSelf: false,
+			name: "cnsync",
+			path: dest
+		};
+	}
+	const consumers = projects.filter((p) => !(p.isSelf || p.isCnsync));
+	return {
+		cnsync,
+		consumers,
+		self
+	};
+};
+const discoverSources = async (searchRoot) => {
+	const home = searchRoot ?? homedir();
+	const reposDir = join(home, CONFIG_DIR, "repos");
+	const selfDir = join(reposDir, PKG_NAME);
+	const cnsyncDir = join(reposDir, "cnsync");
+	let self;
+	let cnsync;
+	if (existsSync(selfDir)) self = {
+		isCnsync: false,
+		isSelf: true,
+		name: PKG_NAME,
+		path: selfDir
+	};
+	if (existsSync(cnsyncDir)) cnsync = {
+		isCnsync: true,
+		isSelf: false,
+		name: "cnsync",
+		path: cnsyncDir
+	};
+	if (!(self && cnsync)) {
+		const found = (await $`rg -l '"${PKG_NAME}"' ${home} -g package.json -g '!**/node_modules/**' -g '!**/.cache/**' --max-count 1`.quiet().nothrow()).stdout.toString().trim().split("\n").filter(Boolean).map((f) => dirname(f));
+		if (!self) {
+			const dir = found.find((d) => {
+				const n = d.split("/").pop();
+				return n === PKG_NAME || n === "pm4ai-monorepo";
+			});
+			if (dir) self = {
+				isCnsync: false,
+				isSelf: true,
+				name: PKG_NAME,
+				path: (await $`git rev-parse --show-toplevel`.cwd(dir).quiet().nothrow()).stdout.toString().trim() || dir
+			};
+		}
+		if (!cnsync) {
+			const match = (await Promise.all(found.map(async (d) => ({
+				d,
+				is: await isCnsyncRepo(d)
+			})))).find((c) => c.is);
+			if (match) cnsync = {
+				isCnsync: true,
+				isSelf: false,
+				name: "cnsync",
+				path: match.d
+			};
+		}
+	}
+	if (!self) {
+		await cloneIfMissing(PKG_NAME, selfDir);
+		self = {
+			isCnsync: false,
+			isSelf: true,
+			name: PKG_NAME,
+			path: selfDir
+		};
+	}
+	if (!cnsync) {
+		await cloneIfMissing("cnsync", cnsyncDir);
+		cnsync = {
+			isCnsync: true,
+			isSelf: false,
+			name: "cnsync",
+			path: cnsyncDir
+		};
+	}
+	return {
+		cnsync,
+		self
+	};
+};
+//#endregion
+export { discoverSources as n, discover as t };