auto-mode 0.21.0 → 1.0.1

package/README.md

@@ -18,7 +18,7 @@ auto-mode needs node 24 or later, Claude Code, and a TypeSafe API key for Jev.
 
 ```sh
 npm i -g auto-mode
-claude --plugin-dir "$(npm root -g)/auto-mode/mods/auto-mode"
+claude --plugin-dir "$(auto-mode mod-path)"
 ```
 
 Export your key as `TYPESAFE_API_KEY`, or point the configuration at a command that prints it.
@@ -54,8 +54,7 @@ You can call auto-mode's core APIs from your own code. `parseActionRequest` read
 mod sends the CLI ([the contract](./docs/architecture/mod.md#the-contract)), and `classifyAction`
 runs it through [the stages](./docs/architecture/overview.md#the-path-of-a-prompted-call) from the
 local rules to the judge. The two options in the example apply the denial budget and write the
-action log, as the CLI does, and `recordScope` adds what a finished Bash call created to the
-session's scope.
+action log, as the CLI does.
 
 ```ts
 import { classifyAction, loadConfig, parseActionRequest } from 'auto-mode';

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { C as readHostEnvironment, T as resolveXDGDir, a as classifyAction, b as loadConfig, i as recordScope, m as writeActionDiagnostic, n as parseScopeRecordRequest, p as loadPolicy, r as parseActionRequest, t as renderVerdict, v as findGitEntry } from "./render-verdict-CE3ojHJk.js";
-import { chmod, mkdir, open, realpath, stat } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { C as resolveXDGDir, D as string, E as strictObject, S as CLI_LIMITS, T as number, _ as findGitEntry, a as EMPTY_SESSION_SCOPE, b as readHostEnvironment, c as loadPolicy, d as writeActionDiagnostic, f as toRepositorySlug, g as findCheckout, h as isUnresolvedWord, i as loadSessionScope, l as resolveShippedPolicyDir, m as resolveShellPath, n as classifyAction, o as splitGitCommand, p as collectShellCommands, r as resolveSessionScopePath, s as M, t as parseActionRequest, u as loadCheckoutFacts, v as DEFAULT_SCOPE_SOURCES, w as updateJSONFile, x as runCapped, y as loadConfig } from "./parse-action-request-BfkmQxEC.js";
 import { randomUUID } from "node:crypto";
-import { constants } from "node:fs";
+import { chmod, mkdir, open, readFile, realpath, stat } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { constants, existsSync } from "node:fs";
 import { text } from "node:stream/consumers";
 import { parseArgs } from "node:util";
 //#region src/capture/resolve-capture-dir.ts
@@ -74,15 +74,313 @@ async function writeOwnerFile(path, text, flag) {
 //#region src/config/build-jev-only-config.ts
 function buildJevOnlyConfig(config) {
 	if (config.provider.protocol !== "system-one") return null;
+	const judge = config.judge === void 0 || config.judge === null ? config.judge : {
+		...config.judge,
+		timeoutMs: Math.min(config.judge.timeoutMs, CLI_LIMITS.judgeMs)
+	};
 	return {
 		...config,
 		provider: {
 			...config.provider,
-			timeoutMs: Math.min(config.provider.timeoutMs, 5e3)
-		}
+			timeoutMs: Math.min(config.provider.timeoutMs, CLI_LIMITS.jevMs)
+		},
+		...judge === void 0 ? {} : { judge }
+	};
+}
+//#endregion
+//#region src/config/resolve-shipped-mod-dir.ts
+function resolveShippedModDir(startDir = import.meta.dirname) {
+	const modDir = join(dirname(resolveShippedPolicyDir(startDir)), "mods", "auto-mode");
+	if (!existsSync(join(modDir, ".claude-plugin", "plugin.json"))) throw new Error("auto-mode cannot find its shipped mod");
+	return modDir;
+}
+//#endregion
+//#region src/scope/read-pull-request.ts
+const LOOKUP_TIMEOUT_MS = 5e3;
+const MAX_LOOKUP_OUTPUT_BYTES = 65536;
+async function readPullRequest(repository, number, options = {}) {
+	const [file, ...prefix] = options.command ?? ["gh"];
+	const args = [
+		"pr",
+		"view",
+		String(number),
+		"--repo",
+		repository,
+		"--json",
+		"headRefName,createdAt"
+	];
+	const result = await runCapped(file, [
+		...prefix,
+		...args,
+		"--jq",
+		"[.headRefName, .createdAt] | @tsv"
+	], {
+		signal: AbortSignal.timeout(options.timeoutMs ?? LOOKUP_TIMEOUT_MS),
+		maxOutputBytes: MAX_LOOKUP_OUTPUT_BYTES
+	});
+	const [head = "", created = ""] = result.stdout.trim().split("	");
+	const createdAt = Date.parse(created);
+	return result.exitCode === 0 && head !== "" && !Number.isNaN(createdAt) ? {
+		head,
+		createdAt
+	} : null;
+}
+//#endregion
+//#region src/git/read-branch-created-at.ts
+async function readBranchCreatedAt(commonDir, branch) {
+	if (!/^[\w./-]+$/u.test(branch) || branch.split("/").includes("..")) return null;
+	const [first = ""] = (await readFile(join(commonDir, "logs", "refs", "heads", branch), "utf8").catch(() => "")).split("\n");
+	const seconds = /^0+ [\da-f]+ .* (?<time>\d+) [+-]\d{4}\t/u.exec(first)?.groups?.["time"];
+	return seconds === void 0 ? null : Number(seconds) * 1e3;
+}
+//#endregion
+//#region src/scope/collect-pull-request-addresses.ts
+function collectPullRequestAddresses(text) {
+	const addresses = /* @__PURE__ */ new Map();
+	for (const match of text.matchAll(PULL_REQUEST_URL)) {
+		const repository = toRepositorySlug(`https://${match.groups?.["repository"] ?? ""}`);
+		const number = Number(match.groups?.["number"]);
+		if (repository !== null) addresses.set(`${repository}#${String(number)}`, {
+			repository,
+			number
+		});
+	}
+	return [...addresses.values()];
+}
+const PULL_REQUEST_URL = /https:\/\/(?<repository>[^/\s]+\/[^/\s]+\/[^/\s]+)\/pull\/(?<number>[1-9]\d*)\b/gu;
+//#endregion
+//#region mods/auto-mode/contract/scope-commands.ts
+const SCOPE_COMMANDS = {
+	git: [
+		"worktree add",
+		"checkout",
+		"switch",
+		"branch"
+	],
+	gh: ["pr create"]
+};
+//#endregion
+//#region src/scope/collect-scope-events.ts
+function collectScopeEvents(command, cwd, home) {
+	return collectShellCommands(command, cwd, home).flatMap((entry) => {
+		const [name, ...args] = entry.words;
+		const directory = entry.directory;
+		if (directory === null) return [];
+		if (name === "git") return collectGitEvents(args, directory, home);
+		return name === "gh" && findScopeCommand(SCOPE_COMMANDS.gh, args) !== null ? [{
+			kind: "pull-request",
+			directory,
+			head: findOptionValue(args, ["--head", "-H"])
+		}] : [];
+	});
+}
+function collectGitEvents(args, cwd, home) {
+	const git = splitGitCommand(args, cwd, home);
+	const found = findScopeCommand(SCOPE_COMMANDS.git, git.args);
+	if (git.directory === null || found === null) return [];
+	return GIT_EVENT_COLLECTORS[found.command](found.rest, git.directory, home);
+}
+function findScopeCommand(commands, args) {
+	for (const command of commands) {
+		const words = command.split(" ");
+		if (words.every((word, index) => args[index] === word)) return {
+			command,
+			rest: args.slice(words.length)
+		};
+	}
+	return null;
+}
+const GIT_EVENT_COLLECTORS = {
+	"worktree add": collectWorktreeEvents,
+	checkout: collectSwitchEvents,
+	switch: collectSwitchEvents,
+	branch: collectBranchEvents
+};
+function collectWorktreeEvents(rest, directory, home) {
+	const path = findWorktreePath(rest);
+	const resolved = path === null ? null : resolveShellPath(directory, path, home);
+	return resolved === null ? [] : [{
+		kind: "worktree",
+		path: resolved
+	}];
+}
+const WORKTREE_VALUE_OPTIONS = /* @__PURE__ */ new Set([
+	"-b",
+	"-B",
+	"--reason"
+]);
+function findWorktreePath(args) {
+	for (let index = 0; index < args.length; index += 1) {
+		const word = args[index] ?? "";
+		if (WORKTREE_VALUE_OPTIONS.has(word)) index += 1;
+		else if (!word.startsWith("-")) return word;
+	}
+	return null;
+}
+const BRANCH_CREATE_OPTIONS = /* @__PURE__ */ new Set([
+	"-b",
+	"-B",
+	"-c",
+	"-C",
+	"--create",
+	"--force-create"
+]);
+const BRANCH_OTHER_OPTIONS = /^-(?:d|D|m|M|c|C|l|a|r|v|vv|u)$|^--(?:delete|move|copy|list|all|remotes|verbose|show-current|contains|no-contains|merged|no-merged|points-at|format|sort|set-upstream-to|unset-upstream|edit-description)/u;
+function collectSwitchEvents(rest, directory) {
+	const name = findOptionValue(rest, [...BRANCH_CREATE_OPTIONS]);
+	return name === null ? [] : [{
+		kind: "branch",
+		name,
+		directory
+	}];
+}
+function collectBranchEvents(rest, directory) {
+	if (rest.some((word) => BRANCH_OTHER_OPTIONS.test(word))) return [];
+	const name = rest.find((word) => !word.startsWith("-"));
+	return name === void 0 || isUnresolvedWord(name) ? [] : [{
+		kind: "branch",
+		name,
+		directory
+	}];
+}
+function findOptionValue(args, options) {
+	const index = args.findIndex((word) => options.includes(word));
+	const value = index === -1 ? void 0 : args[index + 1];
+	return value === void 0 || isUnresolvedWord(value) ? null : value;
+}
+//#endregion
+//#region src/scope/merge-session-scope.ts
+function mergeSessionScope(all) {
+	const branches = /* @__PURE__ */ new Map();
+	const pullRequests = /* @__PURE__ */ new Map();
+	for (const branch of all.flatMap((scope) => scope.branches)) branches.set(`${branch.commonDir}\0${branch.name}`, branch);
+	for (const pull of all.flatMap((scope) => scope.pullRequests)) pullRequests.set(`${pull.repository}#${String(pull.number)}`, pull);
+	return {
+		worktrees: [...new Set(all.flatMap((scope) => scope.worktrees))],
+		branches: [...branches.values()],
+		pullRequests: [...pullRequests.values()]
 	};
 }
 //#endregion
+//#region src/scope/write-session-scope.ts
+async function writeSessionScope(path, added, clock) {
+	await updateJSONFile(path, loadSessionScope, (current) => mergeSessionScope([current, added]), clock);
+}
+//#endregion
+//#region src/scope/update-session-scope.ts
+const MAX_CALL_AGE_MS = 9e5;
+async function updateSessionScope(request, options) {
+	const age = options.now - request.startedAt;
+	if (age < -6e4 || age > MAX_CALL_AGE_MS) return EMPTY_SESSION_SCOPE;
+	const events = collectScopeEvents(request.command, request.cwd, options.home);
+	const scope = mergeSessionScope(await Promise.all(events.map((event) => tryVerifyScopeEvent(event, request, options))));
+	if (scope.worktrees.length + scope.branches.length + scope.pullRequests.length > 0) await writeSessionScope(resolveSessionScopePath(options.stateDir, request.sessionID), scope, options.lockClock);
+	return scope;
+}
+async function tryVerifyScopeEvent(event, request, options) {
+	try {
+		return await (options.verifyEvent === void 0 ? verifyScopeEvent(event, request, options) : options.verifyEvent(event, request));
+	} catch {
+		return EMPTY_SESSION_SCOPE;
+	}
+}
+const FORGE_CLOCK_SKEW_MS = 6e4;
+const FILE_CLOCK_SLACK_MS = 50;
+function verifyScopeEvent(event, request, options) {
+	return M(event).returnType().with({ kind: "worktree" }, (worktree) => verifyWorktreeEvent(worktree.path, request, options)).with({ kind: "branch" }, (branch) => verifyBranchEvent(branch, request, options)).with({ kind: "pull-request" }, (pull) => verifyPullRequestEvent(pull.directory, request, options)).exhaustive();
+}
+async function verifyWorktreeEvent(path, request, options) {
+	const link = await stat(join(path, ".git"));
+	const facts = await loadCheckoutFacts(path, options.env);
+	const checkout = facts.checkout;
+	if (!link.isFile() || link.mtimeMs < request.startedAt - FILE_CLOCK_SLACK_MS || checkout?.worktree !== path) return EMPTY_SESSION_SCOPE;
+	const branch = facts.head?.branch ?? null;
+	if (branch === null) return {
+		...EMPTY_SESSION_SCOPE,
+		worktrees: [path]
+	};
+	const isNew = await isBranchCreatedSince(checkout.commonDir, branch, request.startedAt);
+	return {
+		...EMPTY_SESSION_SCOPE,
+		worktrees: [path],
+		branches: isNew ? [{
+			name: branch,
+			commonDir: checkout.commonDir
+		}] : []
+	};
+}
+async function verifyBranchEvent(event, request, options) {
+	const checkout = await findCheckout(event.directory, options.env);
+	if (checkout === null) return EMPTY_SESSION_SCOPE;
+	return await isBranchCreatedSince(checkout.commonDir, event.name, request.startedAt) ? {
+		...EMPTY_SESSION_SCOPE,
+		branches: [{
+			name: event.name,
+			commonDir: checkout.commonDir
+		}]
+	} : EMPTY_SESSION_SCOPE;
+}
+async function verifyPullRequestEvent(directory, request, options) {
+	const facts = await loadCheckoutFacts(directory, options.env);
+	if (facts.checkout === null) return EMPTY_SESSION_SCOPE;
+	const repositories = new Set(facts.remotes.map((remote) => toRepositorySlug(remote.url)));
+	const addresses = collectPullRequestAddresses(request.resultText).filter((address) => repositories.has(address.repository));
+	const pulls = await Promise.all(addresses.map(async (address) => {
+		const pull = await options.readPullRequest(address.repository, address.number);
+		return pull !== null && pull.createdAt >= request.startedAt - FORGE_CLOCK_SKEW_MS ? [{
+			...address,
+			head: pull.head
+		}] : [];
+	}));
+	return {
+		...EMPTY_SESSION_SCOPE,
+		pullRequests: pulls.flat()
+	};
+}
+async function isBranchCreatedSince(commonDir, branch, since) {
+	const createdAt = await readBranchCreatedAt(commonDir, branch);
+	if (createdAt === null || createdAt < Math.floor(since / 1e3) * 1e3) return false;
+	const ref = await stat(join(commonDir, "refs", "heads", branch)).catch(() => null);
+	return ref !== null && ref.mtimeMs >= since - FILE_CLOCK_SLACK_MS;
+}
+//#endregion
+//#region src/record-scope.ts
+async function recordScope(request, config, options = {}) {
+	const host = options.host ?? readHostEnvironment();
+	if (!Object.values(config.scopeSources ?? DEFAULT_SCOPE_SOURCES).some((source) => source.kind === "session")) return EMPTY_SESSION_SCOPE;
+	return await updateSessionScope(request, {
+		now: options.now ?? Date.now(),
+		stateDir: resolveXDGDir(host, "state"),
+		home: host.home,
+		env: host.env,
+		readPullRequest
+	});
+}
+//#endregion
+//#region src/request/scope-record-request-schema.ts
+const scopeRecordRequestSchema = strictObject({
+	sessionID: string().min(1),
+	cwd: string().min(1),
+	startedAt: number().int().positive(),
+	command: string().min(1),
+	resultText: string()
+});
+//#endregion
+//#region src/request/parse-scope-record-request.ts
+function parseScopeRecordRequest(body) {
+	const parsed = scopeRecordRequestSchema.safeParse(body);
+	return parsed.success ? parsed.data : null;
+}
+//#endregion
+//#region src/request/render-verdict.ts
+function renderVerdict(verdict) {
+	const rendered = M(verdict).returnType().with({ kind: "allow" }, () => ({ decision: "allow" })).with({ kind: "deny" }, (denied) => ({
+		decision: "deny",
+		reason: `[${denied.rule}] ${denied.reason}`
+	})).exhaustive();
+	return JSON.stringify(rendered);
+}
+//#endregion
 //#region src/request/to-mod-request.ts
 function toModRequest(request) {
 	const context = request.decisionContext;
@@ -120,6 +418,7 @@ Usage:
   auto-mode run              Read an action request on stdin, write a verdict on stdout
   auto-mode print-prompt     Print the system prompt the classifier receives
   auto-mode record           Read a finished Bash call on stdin, add what it created to the session's scope
+  auto-mode mod-path         Print the directory of the Claude Code mod this package ships
 
 Options:
   --classifier <path>   Use this framework file instead of the shipped one
@@ -158,6 +457,13 @@ async function runCLI(argv, io) {
 		io.stdout.write(`${prompt}\n`);
 		return 0;
 	}
+	if (command === "mod-path") try {
+		io.stdout.write(`${resolveShippedModDir()}\n`);
+		return 0;
+	} catch (error) {
+		io.stderr.write(`auto-mode: ${error instanceof Error ? error.message : String(error)}\n`);
+		return 1;
+	}
 	io.stderr.write(`auto-mode: unknown command '${command}'\n\n${USAGE}`);
 	return 2;
 }
@@ -268,8 +574,7 @@ async function runRecord(io) {
 	const request = parseScopeRecordRequest(body);
 	if (request === null) return 0;
 	try {
-		const config = await loadConfig(void 0, io.host);
-		await recordScope(request, config, { host: io.host });
+		await recordScope(request, await loadConfig(void 0, io.host), { host: io.host });
 	} catch {
 		io.stderr.write("auto-mode: session scope unavailable\n");
 	}