@marver-design/marver 0.21.0 → 0.22.1

package/dist/config-DJxMRVD8.mjs

@@ -0,0 +1,373 @@
+import { U as readDescription } from "./board-status-CWGHIdo_.mjs";
+import { accessSync, constants, existsSync, readFileSync, statSync } from "node:fs";
+import { delimiter, isAbsolute, join } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/server/detect.ts
+function readJson(file) {
+	try {
+		return JSON.parse(stripJsonComments(readFileSync(file, "utf8")));
+	} catch {
+		return null;
+	}
+}
+function stripJsonComments(s) {
+	let out = "", inStr = false, inLine = false, inBlock = false;
+	for (let i = 0; i < s.length; i++) {
+		const c = s[i], n = s[i + 1];
+		if (inLine) {
+			if (c === "\n") {
+				inLine = false;
+				out += c;
+			}
+			continue;
+		}
+		if (inBlock) {
+			if (c === "*" && n === "/") {
+				inBlock = false;
+				i++;
+			}
+			continue;
+		}
+		if (inStr) {
+			out += c;
+			if (c === "\\") {
+				out += n ?? "";
+				i++;
+			} else if (c === "\"") inStr = false;
+			continue;
+		}
+		if (c === "\"") {
+			inStr = true;
+			out += c;
+			continue;
+		}
+		if (c === "/" && n === "/") {
+			inLine = true;
+			i++;
+			continue;
+		}
+		if (c === "/" && n === "*") {
+			inBlock = true;
+			i++;
+			continue;
+		}
+		out += c;
+	}
+	let res = "", inS = false;
+	for (let i = 0; i < out.length; i++) {
+		const c = out[i];
+		if (inS) {
+			res += c;
+			if (c === "\\") {
+				res += out[i + 1] ?? "";
+				i++;
+			} else if (c === "\"") inS = false;
+			continue;
+		}
+		if (c === "\"") {
+			inS = true;
+			res += c;
+			continue;
+		}
+		if (c === ",") {
+			let j = i + 1;
+			while (j < out.length && /\s/.test(out[j])) j++;
+			if (out[j] === "}" || out[j] === "]") continue;
+		}
+		res += c;
+	}
+	return res;
+}
+function detectHost(root) {
+	const pkg = readJson(join(root, "package.json")) ?? {};
+	const deps = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	const twRange = deps["tailwindcss"];
+	const tailwind = !twRange ? null : /(^|[^\d])4\./.test(twRange) || twRange.startsWith("^4") || twRange.startsWith("~4") ? 4 : 3;
+	const router = deps["next"] ? "next" : deps["react-router"] || deps["react-router-dom"] ? "react-router" : null;
+	const routerPkg = deps["react-router-dom"] ? "react-router-dom" : "react-router";
+	const toaster = deps["sonner"] ? "sonner" : deps["react-hot-toast"] ? "react-hot-toast" : null;
+	let shadcn = null;
+	const comp = readJson(join(root, "components.json"));
+	if (comp?.tailwind?.css) shadcn = {
+		themeCss: comp.tailwind.css,
+		uiAlias: comp.aliases?.ui ?? "@/components/ui"
+	};
+	const themeCss = shadcn?.themeCss && existsSync(join(root, shadcn.themeCss)) ? shadcn.themeCss : firstExisting(root, [
+		"src/index.css",
+		"src/styles/theme.css",
+		"src/styles/globals.css",
+		"src/app/globals.css",
+		"app/globals.css",
+		"src/globals.css",
+		"src/style.css",
+		"styles/globals.css"
+	]);
+	const ts = readJson(join(root, "tsconfig.json"));
+	const include = ts?.include;
+	const exclude = ts?.exclude ?? [];
+	const sweeps = ts != null && !exclude.some((e) => e === "design" || e.startsWith("design/")) && (!include || include.some((i) => i === "." || i.startsWith("**") || i.startsWith("design")));
+	return {
+		tailwind,
+		router,
+		routerPkg,
+		toaster,
+		shadcn,
+		themeCss,
+		tsconfigSweepsDesign: !!sweeps
+	};
+}
+function firstExisting(root, candidates) {
+	for (const c of candidates) if (existsSync(join(root, c))) return c;
+	return null;
+}
+//#endregion
+//#region src/server/jam/agent.ts
+/**
+* Which coding agent drives this repo.
+*
+* Live Jam is ON by default, so this is the answer to "on by default with WHAT" - asked
+* once by `init` (which writes the answer into design/config.ts, where it is visible and
+* editable) and again at every dev boot, so a workspace that predates the block - or a
+* human who switched tools - still jams without editing anything.
+*
+* The tool RUNNING us wins: `init` is usually run BY the agent, so its env markers are
+* evidence rather than a guess. Whatever wins must still be on PATH - the daemon has to
+* spawn it.
+*/
+/** Ordered by preference when a machine has several installed and none is running us. */
+const AGENTS = [
+	"claude",
+	"codex",
+	"cursor",
+	"droid",
+	"opencode",
+	"grok",
+	"pi"
+];
+/** Env vars each CLI sets in the processes it spawns. Deliberately NOT CODEX_HOME or
+*  ANTHROPIC_API_KEY: those are configuration a human exports by hand, not evidence that
+*  the tool is running right now. (opencode's `AGENT=1` and pi's `AI_AGENT` are skipped
+*  for the same reason in reverse - too generic to prove WHICH tool is running.)
+*  droid and grok set no marker at all in the shells they spawn (verified against the
+*  grok-build source and droid 0.200.0), so they are found by PATH order only. */
+const MARKERS = {
+	claude: ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"],
+	codex: ["CODEX_SANDBOX", "CODEX_THREAD_ID"],
+	cursor: ["CURSOR_AGENT"],
+	droid: [],
+	opencode: ["OPENCODE", "OPENCODE_PID"],
+	grok: [],
+	pi: ["PI_CODING_AGENT", "PI_SESSION_ID"]
+};
+/** The executable each agent name maps to. Only cursor differs: its CLI installs BOTH
+*  `cursor-agent` and a bare `agent` - and grok's installer symlinks `agent` too, so the
+*  short name is a coin flip on a machine with both. The long name is unambiguous. */
+const AGENT_BIN = {
+	claude: "claude",
+	codex: "codex",
+	cursor: "cursor-agent",
+	droid: "droid",
+	opencode: "opencode",
+	grok: "grok",
+	pi: "pi"
+};
+/** The valid `jam.agent` values as an English list - one string, so every surface
+*  (config warning, init note, dev boot line) names the same set and none goes stale. */
+const AGENT_NAMES = `${AGENTS.slice(0, -1).map((a) => `"${a}"`).join(", ")}, or "${AGENTS[AGENTS.length - 1]}"`;
+/** Is `cmd` an executable FILE on PATH? A direct stat per PATH entry - no spawn, no shell,
+*  so this is safe to call on every dev boot. Two deliberate narrowings, both in service of
+*  "found means spawnable", because arming an agent that cannot run is worse than staying off:
+*
+*  - `isFile`, because a directory carries the execute bit too (it means "traversable"), so an
+*    access check alone would call a folder named `claude` an agent.
+*  - the bare name only, no PATHEXT: the daemon spawns without a shell, and Node cannot run a
+*    Windows `.cmd`/`.bat` shim that way. Finding one would arm a job that fails on every run.
+*
+*  Only ABSOLUTE PATH entries count. An empty entry means the current directory on POSIX, and
+*  a relative one (`.`, `bin`) resolves against it too - and the current directory is the repo
+*  that was just opened, so a `claude` binary shipped inside it is precisely what must never
+*  be found and spawned. */
+function onPath(cmd, env = process.env) {
+	for (const dir of (env.PATH ?? "").split(delimiter)) {
+		if (!isAbsolute(dir)) continue;
+		try {
+			const file = join(dir, cmd);
+			if (statSync(file).isFile()) {
+				accessSync(file, constants.X_OK);
+				return true;
+			}
+		} catch {}
+	}
+	return false;
+}
+/** The agent to jam with, or undefined when this machine has none installed.
+*
+*  One knowingly-imperfect case: agents nest, and env is inherited, so a codex run started
+*  FROM Claude Code carries both marker families and this picks claude. Env has no depth to
+*  read, and walking the process tree to find the nearest agent ancestor costs more than the
+*  case is worth - so the answer is made visible instead of clever: `init` prints the agent
+*  it chose and writes it into design/config.ts, and instructions/jam.md has the agent confirm
+*  that line names the tool it actually is. One word to correct, once per repo. */
+function detectAgent(env = process.env) {
+	const running = AGENTS.find((a) => MARKERS[a].some((k) => env[k]));
+	if (running && onPath(AGENT_BIN[running], env)) return running;
+	return AGENTS.find((a) => onPath(AGENT_BIN[a], env));
+}
+//#endregion
+//#region src/server/config.ts
+const DEFAULTS = {
+	mode: "studio",
+	theme: null,
+	viewports: {
+		mobile: {
+			width: 390,
+			height: 844
+		},
+		tablet: {
+			width: 768,
+			height: 1024
+		},
+		laptop: {
+			width: 1280,
+			height: 800
+		},
+		monitor: {
+			width: 1920,
+			height: 1080
+		}
+	},
+	themes: ["light", "dark"],
+	port: 5199,
+	zoomSpeed: 1,
+	share: { branding: true }
+};
+/** Load design/config.ts via native TS import (Node >= 22.18). Missing or broken fields fall back to defaults. */
+async function loadConfig(root) {
+	const file = join(root, "design", "config.ts");
+	if (!existsSync(file)) return {
+		...DEFAULTS,
+		...jamFields(void 0)
+	};
+	try {
+		const user = (await import(`${pathToFileURL(file).href}?t=${Date.now()}`)).default ?? {};
+		return {
+			...DEFAULTS,
+			...user,
+			viewports: validViewports(user.viewports) ?? DEFAULTS.viewports,
+			themes: Array.isArray(user.themes) && user.themes.length ? user.themes.map(String) : DEFAULTS.themes,
+			port: validPort(user.port) ?? DEFAULTS.port,
+			zoomSpeed: validZoom(user.zoomSpeed) ?? DEFAULTS.zoomSpeed,
+			description: readDescription(user.description),
+			share: {
+				branding: user.share?.branding !== false,
+				name: typeof user.share?.name === "string" ? user.share.name : void 0,
+				logo: typeof user.share?.logo === "string" ? user.share.logo : void 0,
+				frontDoor: user.share?.frontDoor !== false && user.share?.front_door !== false,
+				notify: user.share?.notify !== false
+			},
+			...jamFields(user.jam)
+		};
+	} catch (err) {
+		console.error(`[marver] design/config.ts failed to load, using defaults and leaving Live Jam OFF:\n  ${err.message}`);
+		return {
+			...DEFAULTS,
+			jamOff: "unreadable"
+		};
+	}
+}
+const validDim = (n) => typeof n === "number" && Number.isFinite(n) && n >= 1 && n <= 2e4;
+function validPort(n) {
+	return typeof n === "number" && Number.isInteger(n) && n > 0 && n < 65536 ? n : null;
+}
+function validZoom(n) {
+	return typeof n === "number" && Number.isFinite(n) && n >= .1 && n <= 10 ? n : null;
+}
+/** Six frames at once is what a jam actually feels like - at 3, half of a multi-frame
+*  ask sat waiting on the other half while the human watched. */
+const DEFAULT_CONCURRENCY = 6;
+/** A config value, printable in a warning. Never throws - a formatter that can crash inside an
+*  error path (JSON.stringify does, on a BigInt) turns a clear message into a mystery. */
+const show = (v) => {
+	try {
+		return JSON.stringify(v) ?? String(v);
+	} catch {
+		return String(v);
+	}
+};
+/** A `{...}` written by hand, not a Date/Map/class instance that merely types as "object". */
+const plainObject = (v) => {
+	if (!v || typeof v !== "object") return false;
+	const proto = Object.getPrototypeOf(v);
+	return proto === Object.prototype || proto === null;
+};
+/** The agent to arm with - or, when the human NAMED one we cannot use, why not (said once,
+*  here, because a bad `jam.agent` is a config-file error like any other).
+*
+*  A named agent is never quietly swapped for another: running a different tool than the one
+*  asked for is worse than not running. Nor is one armed that cannot be spawned - that would
+*  claim every @marver mention, fail it, and never retry. */
+function resolveAgent(named) {
+	if (named === void 0) return detectAgent() ?? "no-agent";
+	if (typeof named !== "string" || !Object.hasOwn(AGENT_BIN, named)) {
+		console.warn(`[marver] design/config.ts: jam.agent ${show(named)} is not an agent marver can spawn - Live Jam is off. Use ${AGENT_NAMES}.`);
+		return "bad-agent";
+	}
+	const agent = named;
+	if (!onPath(AGENT_BIN[agent])) {
+		console.warn(`[marver] design/config.ts names jam.agent "${agent}", but \`${AGENT_BIN[agent]}\` is not on PATH - Live Jam is off until it is installed.`);
+		return "bad-agent";
+	}
+	return agent;
+}
+/** Resolve the jam block. Live Jam is ON by default: an absent or partial `jam` resolves
+*  to whatever agent CLI this machine has, so a fresh workspace jams with nothing
+*  configured and an old one needs no re-init. `jam: false` is the off switch. */
+function resolveJam(v) {
+	if (v === false) return "opted-out";
+	const shape = v === void 0 || v === true ? {} : typeof v === "string" ? { agent: v } : plainObject(v) ? v : null;
+	if (!shape) {
+		console.warn(`[marver] design/config.ts: jam must be false, an agent name, or an options object - got ${show(v)}. Live Jam is off.`);
+		return "bad-agent";
+	}
+	const j = shape;
+	const agent = resolveAgent(j.agent);
+	if (agent === "no-agent" || agent === "bad-agent") return agent;
+	const c = j.concurrency;
+	return {
+		agent,
+		concurrency: typeof c === "number" && Number.isInteger(c) && c >= 1 && c <= 16 ? c : DEFAULT_CONCURRENCY,
+		subagents: j.subagents !== false,
+		proactive: j.proactive === true
+	};
+}
+/** Exactly one of `jam` (armed) or `jamOff` (why not) - so the dev server can speak up about
+*  the one off-state nothing has reported yet, and stay quiet about the rest. BOTH keys are
+*  always written: these spread over the user's own `jam`, and a raw `jam: false` reaching the
+*  server as config would arm the daemon against a truthy object check. */
+function jamFields(v) {
+	const r = resolveJam(v);
+	return typeof r === "string" ? {
+		jam: void 0,
+		jamOff: r
+	} : {
+		jam: r,
+		jamOff: void 0
+	};
+}
+function validViewports(v) {
+	if (!v || typeof v !== "object") return null;
+	const out = {};
+	for (const [k, val] of Object.entries(v)) {
+		const vp = val;
+		if (validDim(vp?.width) && validDim(vp?.height)) out[k] = {
+			width: Math.round(vp.width),
+			height: Math.round(vp.height)
+		};
+	}
+	return Object.keys(out).length ? out : null;
+}
+//#endregion
+export { readJson as a, detectHost as i, loadConfig as n, detectAgent as r, DEFAULTS as t };