mainflow 0.6.0

package/dist/hooks.js

@@ -0,0 +1,171 @@
+import { D as turnReminder, E as sessionBriefing, G as DATA_DIR, J as worktreesOf, K as currentBranch, L as HubError, R as loadHub, S as setSessionStatus, _ as ensureSession, q as findHubRoot, x as setSessionInfo, y as readSession } from "./dist-BktkzRuK.js";
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+//#region src/hooks.ts
+const SUMMARY_LIMIT = 280;
+/** The parent transcript `<dir>/<session>.jsonl` keeps its subagents under `<dir>/<session>/subagents/`. */
+function subagentTranscript(parentTranscript, agentId) {
+	return join(parentTranscript.replace(/\.jsonl$/, ""), "subagents", `agent-${agentId}.jsonl`);
+}
+function readMeta(transcript) {
+	const file = transcript.replace(/\.jsonl$/, ".meta.json");
+	if (!existsSync(file)) return {};
+	try {
+		return JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return {};
+	}
+}
+const brief = (text) => {
+	const flat = (text ?? "").replace(/\s+/g, " ").trim();
+	return flat.length > SUMMARY_LIMIT ? `${flat.slice(0, 279)}…` : flat;
+};
+const shortId = (raw) => raw.replace(/[^a-z0-9]/gi, "").toLowerCase().slice(0, 8);
+const claudeCodeSessionId = (raw) => `claude-code-${shortId(raw)}`;
+/**
+* One handler per Claude Code event; each returns what to print for the model, or null. SessionStart and
+* UserPromptSubmit take plain text; PostToolUse takes the hook JSON, since its plain stdout never reaches the model.
+*/
+const CLAUDE_CODE_EVENTS = {
+	"session-start": (root, { payload, envFile, cli }) => {
+		if (!payload.session_id) return null;
+		const id = claudeCodeSessionId(payload.session_id);
+		const cwd = payload.cwd ?? root;
+		ensureSession(root, {
+			id,
+			agent: "claude-code",
+			cwd
+		});
+		const session = setSessionInfo(root, id, {
+			transcript: payload.transcript_path,
+			worktree: worktreesOf(cwd)?.current,
+			branch: currentBranch(cwd) ?? void 0,
+			effort: payload.effort?.level
+		});
+		if (envFile) appendFileSync(envFile, `export MAINFLOW_SESSION=${id}\n`);
+		return sessionBriefing(root, session, {
+			cli,
+			envNote: envFile ? "已設定環境變數 MAINFLOW_SESSION，指令不必再帶 --session" : `執行指令時帶 --session ${id}`
+		});
+	},
+	"user-prompt-submit": (root, { payload, cli }) => {
+		const session = payload.session_id ? readSession(root, claudeCodeSessionId(payload.session_id)) : null;
+		return session ? turnReminder(root, session, { cli }) : null;
+	},
+	"subagent-start": (root, { payload }) => {
+		if (!payload.agent_id) return null;
+		const parent = payload.session_id ? claudeCodeSessionId(payload.session_id) : null;
+		ensureSession(root, {
+			id: claudeCodeSessionId(payload.agent_id),
+			agent: payload.agent_type ? `claude-code/${payload.agent_type}` : "claude-code",
+			cwd: payload.cwd ?? root,
+			delegatedFrom: parent && readSession(root, parent) ? parent : null
+		});
+		return null;
+	},
+	"subagent-stop": (root, { payload }) => {
+		const id = payload.agent_id ? claudeCodeSessionId(payload.agent_id) : null;
+		if (!id || !readSession(root, id)) return null;
+		const transcript = payload.transcript_path ? subagentTranscript(payload.transcript_path, payload.agent_id) : void 0;
+		const meta = transcript ? readMeta(transcript) : {};
+		setSessionInfo(root, id, {
+			transcript: transcript && existsSync(transcript) ? transcript : void 0,
+			description: meta.description,
+			depth: meta.spawnDepth,
+			summary: brief(payload.last_assistant_message) || void 0
+		});
+		setSessionStatus(root, id, "ended");
+		return null;
+	},
+	"post-tool-use": checkAfterWrite
+};
+/** How many problems outside the written file the reminder lists before it only gives the count. */
+const OTHER_PROBLEMS_SHOWN = 5;
+const problemLine = (p) => `- ${p.file}${p.field ? ` › ${p.field}` : ""}：${p.message}`;
+/**
+* The hub a written file belongs to: the nearest `.mainflow` above it that holds config.yaml. It is
+* found from the file itself rather than from the session's directory, because a worktree maps the
+* session to the main tree's hub while the file was written to the worktree's own copy.
+*/
+function hubOfFile(file) {
+	for (let dir = dirname(file); dirname(dir) !== dir; dir = dirname(dir)) if (basename(dir) === ".mainflow" && existsSync(join(dir, "config.yaml"))) return dirname(dir);
+	return null;
+}
+/**
+* After a tool writes under `.mainflow/`, run the same checks as `mainflow check` and hand the problems
+* to the model in the same turn. Edit, Write and MultiEdit name the file; Bash only counts when its
+* command mentions `.mainflow`, a text match that misses paths built from variables. A clean hub, or a
+* write elsewhere, adds nothing.
+*/
+function checkAfterWrite(root, { payload, cli }) {
+	const input = payload.tool_input ?? {};
+	let hub = root;
+	let written = null;
+	if (payload.tool_name === "Bash") {
+		if (!input.command?.includes(".mainflow")) return null;
+	} else {
+		if (!input.file_path) return null;
+		const file = isAbsolute(input.file_path) ? input.file_path : resolve(payload.cwd ?? root, input.file_path);
+		const owner = hubOfFile(file);
+		if (!owner) return null;
+		hub = owner;
+		written = relative(owner, file);
+	}
+	let problems;
+	try {
+		problems = loadHub(hub).problems;
+	} catch (error) {
+		problems = error instanceof HubError ? [...error.problems, {
+			file: `${DATA_DIR}/config.yaml`,
+			field: "",
+			message: error.message
+		}] : [{
+			file: DATA_DIR,
+			field: "",
+			message: error.message
+		}];
+	}
+	if (problems.length === 0) return null;
+	const own = written ? problems.filter((p) => p.file === written) : [];
+	const others = problems.filter((p) => !own.includes(p));
+	const lines = [
+		written && own.length ? `[mainflow] 剛寫入的 ${written} 有 ${own.length} 個問題，改好再繼續：` : `[mainflow] 寫入 .mainflow/ 後，check 找到 ${problems.length} 個問題：`,
+		...own.map(problemLine),
+		...others.length ? [...own.length ? [`其他檔案還有 ${others.length} 個問題：`] : [], ...others.slice(0, OTHER_PROBLEMS_SHOWN).map(problemLine)] : [],
+		...others.length > OTHER_PROBLEMS_SHOWN ? [`還有 ${others.length - OTHER_PROBLEMS_SHOWN} 個沒列出，跑 ${cli} check 看全部。`] : []
+	];
+	return JSON.stringify({ hookSpecificOutput: {
+		hookEventName: "PostToolUse",
+		additionalContext: lines.join("\n")
+	} });
+}
+const HOOK_PLATFORMS = { "claude-code": CLAUDE_CODE_EVENTS };
+/**
+* Run a hook handler. A hook must never break the host session, so outside a hub it stays silent and any
+* failure is reported on stderr while the caller still exits 0.
+*/
+function runHook(platform, event, ctx) {
+	const handler = HOOK_PLATFORMS[platform]?.[event];
+	if (!handler) return {
+		stdout: null,
+		error: `unknown hook ${platform} ${event}; known: ${Object.entries(HOOK_PLATFORMS).flatMap(([p, e]) => Object.keys(e).map((k) => `${p} ${k}`)).join(", ")}`
+	};
+	const root = findHubRoot(ctx.payload.cwd ?? process.cwd());
+	if (!root) return {
+		stdout: null,
+		error: null
+	};
+	try {
+		return {
+			stdout: handler(root, ctx),
+			error: null
+		};
+	} catch (error) {
+		return {
+			stdout: null,
+			error: `mainflow hook ${platform} ${event}: ${error.message}`
+		};
+	}
+}
+//#endregion
+export { HOOK_PLATFORMS, claudeCodeSessionId, runHook, subagentTranscript };

package/dist/host.d.ts

@@ -0,0 +1,24 @@
+//#region src/host.d.ts
+export declare const DEFAULT_UI_PORT = 4320;
+export declare const hostName: (hub: string) => string;
+export declare function siteBlock(hub: string, port: number): string;
+/** Caddy's sites directory: MAINFLOW_CADDY_SITES, or the Homebrew layout {prefix}/etc/caddy/sites; null without either. */
+export declare function caddySites(): string | null;
+export interface HostOptions {
+  reload?: (sites: string) => string | null;
+  running?: () => Promise<boolean>;
+}
+/** The host name URL when Caddy serves it, or why it does not so the caller can fall back to localhost. */
+export type HostResult = {
+  url: string;
+} | {
+  url: null;
+  reason: string;
+};
+/**
+ * Point {hub}.mainflow.localhost at `port`. The site block is rewritten and Caddy reloaded only when the
+ * port differs from what Caddy already has, so an ordinary start leaves Caddy alone. A link owned by a
+ * different hub of the same name stops here: overwriting it would silently take that hub's host name.
+ */
+export declare function syncHost(root: string, hub: string, port: number, options?: HostOptions): Promise<HostResult>;
+//#endregion

package/dist/host.js

@@ -0,0 +1,89 @@
+import { G as DATA_DIR, W as WriteError } from "./dist-BktkzRuK.js";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+//#region src/host.ts
+const DEFAULT_UI_PORT = 4320;
+const hostName = (hub) => `${hub}.mainflow.localhost`;
+function siteBlock(hub, port) {
+	return [
+		`# mainflow hub ${hub}: written by \`mainflow ui\` to match the port it serves on; do not edit.`,
+		`${hostName(hub)} {`,
+		"	tls internal",
+		`\treverse_proxy localhost:${port}`,
+		"}",
+		""
+	].join("\n");
+}
+/** Caddy's sites directory: MAINFLOW_CADDY_SITES, or the Homebrew layout {prefix}/etc/caddy/sites; null without either. */
+function caddySites() {
+	if (process.env.MAINFLOW_CADDY_SITES) return process.env.MAINFLOW_CADDY_SITES;
+	const prefix = spawnSync("brew", ["--prefix"], { encoding: "utf8" });
+	if (prefix.error || prefix.status !== 0) return null;
+	return join(prefix.stdout.trim(), "etc/caddy/sites");
+}
+/** Reload Caddy from the Caddyfile two levels above the sites directory; the error text on failure. */
+function reloadCaddy(sites) {
+	const caddyfile = join(sites, "..", "..", "Caddyfile");
+	const reload = spawnSync("caddy", [
+		"reload",
+		"--config",
+		caddyfile
+	], { encoding: "utf8" });
+	if (reload.error) return reload.error.message;
+	return reload.status === 0 ? null : (reload.stderr || reload.stdout).trim().slice(-300);
+}
+/**
+* Whether Caddy is running, judged by its admin API answering at all. The API refuses requests like
+* Node's fetch with 403 ("client is not allowed to access from origin"), so any response counts; only a
+* refused connection or a timeout means Caddy is down (observed 2026-09-25: checking for 200 reported a
+* running Caddy as stopped). MAINFLOW_CADDY_ADMIN overrides the address.
+*/
+async function caddyRunning() {
+	const admin = process.env.MAINFLOW_CADDY_ADMIN ?? "http://127.0.0.1:2019";
+	try {
+		await fetch(`${admin}/config/`, { signal: AbortSignal.timeout(500) });
+		return true;
+	} catch {
+		return false;
+	}
+}
+const realOf = (path) => existsSync(path) ? realpathSync(path) : resolve(path);
+/**
+* Point {hub}.mainflow.localhost at `port`. The site block is rewritten and Caddy reloaded only when the
+* port differs from what Caddy already has, so an ordinary start leaves Caddy alone. A link owned by a
+* different hub of the same name stops here: overwriting it would silently take that hub's host name.
+*/
+async function syncHost(root, hub, port, options = {}) {
+	const sites = caddySites();
+	if (!sites || !existsSync(sites)) return {
+		url: null,
+		reason: `Caddy's sites directory was not found (${sites ?? "no Homebrew prefix"}); install Caddy and import that directory from the Caddyfile, or set MAINFLOW_CADDY_SITES`
+	};
+	const dir = join(root, DATA_DIR, "local", "caddy");
+	const file = join(dir, `${hub}.caddy`);
+	const link = join(sites, `mainflow-${hub}.caddy`);
+	const linked = lstatSync(link, { throwIfNoEntry: false });
+	if (linked) {
+		const target = linked.isSymbolicLink() ? resolve(dirname(link), readlinkSync(link)) : link;
+		if (existsSync(target) && realOf(target) !== realOf(file)) throw new WriteError(`host name ${hostName(hub)} is already used by another hub (${link} → ${target}); give one of the hubs a different name in its .mainflow/config.yaml`);
+	}
+	const block = siteBlock(hub, port);
+	if ((linked && existsSync(file) ? readFileSync(file, "utf8") : null) !== block) {
+		mkdirSync(dir, { recursive: true });
+		writeFileSync(file, block);
+		if (linked) rmSync(link);
+		symlinkSync(file, link);
+		const failure = (options.reload ?? reloadCaddy)(sites);
+		if (failure) return {
+			url: null,
+			reason: `caddy reload failed: ${failure}`
+		};
+	} else if (!await (options.running ?? caddyRunning)()) return {
+		url: null,
+		reason: "Caddy is not running; start it with `brew services start caddy`"
+	};
+	return { url: `https://${hostName(hub)}` };
+}
+//#endregion
+export { DEFAULT_UI_PORT, caddySites, hostName, siteBlock, syncHost };