auto-mode 0.1.0 → 0.2.0

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { a as loadPolicy, c as hookConfig, h as loadConfig, l as renderVerdict, m as configPath, n as classifyWithModel, o as SETTINGS_PATHS, s as SETUP_NOTES, t as classifyLocally, u as parsePayload } from "./classify-locally-BHl0xiqa.js";
+import { a as loadPolicy, c as buildHookConfig, g as resolveConfigPath, l as renderVerdict, m as loadConfig, n as classifyWithModel, o as SETTINGS_PATHS, s as SETUP_NOTES, t as classifyLocally, u as parsePayload } from "./classify-locally-rTUwxBZi.js";
 import { parseArgs } from "node:util";
+import { text } from "node:stream/consumers";
 //#region src/cli.ts
 const USAGE = `auto-mode — a permission classifier that runs as a hook
 
@@ -15,45 +16,36 @@ Options:
   --explain             With run: also write the reasoning to stderr
   --local-only          With run: skip the model tier
 `;
-async function readStdin() {
-	const chunks = [];
-	for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
-	return Buffer.concat(chunks).toString("utf8");
+function readStdin() {
+	return text(process.stdin);
 }
-/**
-* Decides one tool call. Writing nothing is a real answer: it means auto-mode
-* has no opinion, and the harness then does whatever it would have done alone.
-* That is the right output for an unknown harness, for an event that is not a
-* tool gate, and for anything the local tier declines to judge until the model
-* tier exists.
-*/
 async function run(explain, localOnly) {
 	const raw = await readStdin();
 	let body;
 	try {
 		body = JSON.parse(raw);
 	} catch {
-		return note(explain, "stdin is not JSON, so no verdict");
+		return printNote(explain, "stdin is not JSON, so no verdict");
 	}
 	const payload = parsePayload(body);
-	if (payload === null) return note(explain, "not a tool gate this hook judges, so no verdict");
+	if (payload === null) return printNote(explain, "not a tool gate this hook judges, so no verdict");
 	const local = classifyLocally(payload);
 	if (local.kind === "allow") {
 		process.stdout.write(renderVerdict(payload.event, { kind: "allow" }));
-		return note(explain, `allowed by ${local.exception} (${payload.harness}, local)`);
+		return printNote(explain, `allowed by ${local.exception} (${payload.harness}, local)`);
 	}
-	if (localOnly) return note(explain, `${payload.toolName} needs the model tier, which --local-only skipped`);
+	if (localOnly) return printNote(explain, `${payload.toolName} needs the model tier, which --local-only skipped`);
 	const config = await loadConfig();
 	const outcome = await classifyWithModel(payload, config);
 	if (outcome.verdict !== null) process.stdout.write(renderVerdict(payload.event, outcome.verdict));
-	return note(explain, outcome.note);
+	return printNote(explain, outcome.note);
 }
-function note(explain, text) {
-	if (explain) process.stderr.write(`auto-mode: ${text}\n`);
+function printNote(explain, message) {
+	if (explain) process.stderr.write(`auto-mode: ${message}\n`);
 	return 0;
 }
 async function main(argv) {
-	const { values, positionals } = parseArgs({
+	const args = parseArgs({
 		args: [...argv],
 		allowPositionals: true,
 		options: {
@@ -67,29 +59,28 @@ async function main(argv) {
 			}
 		}
 	});
-	const command = positionals[0];
-	if (values.help === true || command === void 0) {
+	const [command] = args.positionals;
+	if (args.values.help === true || command === void 0) {
 		process.stdout.write(USAGE);
 		return 0;
 	}
-	if (command === "run") return run(values.explain === true, values["local-only"] === true);
+	if (command === "run") return run(args.values.explain === true, args.values["local-only"] === true);
 	if (command === "init") {
-		const harness = positionals[1];
+		const [, harness] = args.positionals;
 		if (harness !== "claude" && harness !== "codex" && harness !== "muse") {
 			process.stderr.write("auto-mode init: name a harness — claude, codex or muse\n");
 			return 2;
 		}
-		const target = harness;
-		process.stdout.write(`# Add this to ${SETTINGS_PATHS[target]}\n`);
-		process.stdout.write(`# Configuration lives at ${configPath()}\n`);
-		process.stdout.write(`${hookConfig(target, `${process.execPath} ${process.argv[1] ?? "auto-mode"} run`)}\n`);
-		for (const line of SETUP_NOTES[target]) process.stdout.write(`# ${line}\n`);
+		process.stdout.write(`# Add this to ${SETTINGS_PATHS[harness]}\n`);
+		process.stdout.write(`# Configuration lives at ${resolveConfigPath()}\n`);
+		process.stdout.write(`${buildHookConfig(harness, `${process.execPath} ${process.argv[1] ?? "auto-mode"} run`)}\n`);
+		for (const line of SETUP_NOTES[harness]) process.stdout.write(`# ${line}\n`);
 		return 0;
 	}
 	if (command === "print-prompt") {
 		const prompt = await loadPolicy({
-			...values.classifier === void 0 ? {} : { classifierPath: values.classifier },
-			...values.rules === void 0 ? {} : { rulesPath: values.rules }
+			classifierPath: args.values.classifier,
+			rulesPath: args.values.rules
 		});
 		process.stdout.write(`${prompt}\n`);
 		return 0;

package/dist/index.d.ts

@@ -1,63 +1,29 @@
 //#region src/config/config.d.ts
-/**
- * How to reach the judging model. Every supported provider speaks the Anthropic
- * Messages API, so one shape covers Claude, Muse, GLM and Kimi — only the base
- * URL, the model id and the key change.
- */
 interface ProviderConfig {
   readonly baseURL: string;
   readonly model: string;
-  /** Environment variable holding the key. Tried first. */
-  readonly apiKeyEnv?: string;
-  /** Command that prints the key. Tried when the variable is unset or empty. */
-  readonly apiKeyCommand?: string;
-  /**
-   * Whether this model reasons before answering. It drives three things at once
-   * — how the prompt asks for the answer, how many tokens to allow, and how long
-   * to wait — because a reasoning model needs more of all three.
-   */
+  readonly apiKeyEnv?: string | undefined;
+  readonly apiKeyCommand?: string | undefined;
   readonly reasoning: boolean;
   readonly maxTokens: number;
   readonly timeoutMs: number;
 }
 interface Config {
   readonly provider: ProviderConfig;
-  readonly classifierPath?: string;
-  readonly rulesPath?: string;
-  /** How many transcript entries to show the model, newest last. */
+  readonly classifierPath?: string | undefined;
+  readonly rulesPath?: string | undefined;
   readonly transcriptEntries: number;
-  /**
-   * What to do when the model cannot be reached or does not answer. `defer`
-   * writes nothing, so the harness asks the operator as it would without this
-   * hook. `deny` fails closed.
-   */
   readonly onFailure: 'defer' | 'deny';
 }
-/**
- * Muse Spark is the default because it reasons, it was correct on every case we
- * measured, and a contributor-tier call costs about a fortieth of the
- * alternatives. Its token budget is not a preference: below roughly 2000 it
- * returns nothing at all.
- */
 export declare const DEFAULT_CONFIG: Config;
-/** Provider presets, so a config need only name one. */
 export declare const PRESETS: Readonly<Record<string, ProviderConfig>>;
-export declare function configPath(): string;
-/**
- * Reads the config, falling back to the shipped defaults. A missing file is
- * normal. A malformed one is not, and it throws rather than silently running a
- * policy the user did not write.
- */
+export declare function resolveConfigPath(): string;
 export declare function loadConfig(path?: string): Promise<Config>;
-/** Reads the key from the environment, then from the helper command. */
 export declare function resolveApiKey(provider: ProviderConfig): Promise<string | null>;
 //#endregion
 //#region src/harness/types.d.ts
-/** A harness is the program that runs the agent and calls this hook. */
 type Harness = 'claude' | 'codex' | 'muse';
-/** The hook events auto-mode acts on. Others are read and ignored. */
 type HookEvent = 'PreToolUse' | 'PermissionRequest';
-/** One tool call, normalised across harnesses. */
 interface HookPayload {
   readonly harness: Harness;
   readonly event: HookEvent;
@@ -65,15 +31,9 @@ interface HookPayload {
   readonly cwd: string;
   readonly toolName: string;
   readonly toolInput: Readonly<Record<string, unknown>>;
-  /** Where the harness keeps the conversation, when it says. */
-  readonly transcriptPath?: string;
-  /** The payload as it arrived, for anything this shape drops. */
+  readonly transcriptPath?: string | undefined;
   readonly raw: Readonly<Record<string, unknown>>;
 }
-/**
- * What auto-mode decides. `ask` hands the call back to the operator, which is
- * what the harness would have done without this hook.
- */
 type Verdict = {
   readonly kind: 'allow';
 } | {
@@ -85,64 +45,16 @@ type Verdict = {
 };
 //#endregion
 //#region src/harness/detect-harness.d.ts
-/**
- * Names the harness that sent a hook payload.
- *
- * The three shapes overlap, so order matters. Muse carries `model_provider`,
- * which neither of the others sends, so it is tested first — Muse also sends
- * `turn_id`, and testing that first would call every Muse payload Codex. Claude
- * is the only one that sends `prompt_id`. Codex is then what is left that
- * carries `turn_id`.
- *
- * Environment variables cannot help here: Muse runs hook commands with a
- * scrubbed environment, so a Muse hook sees none of them.
- */
 export declare function detectHarness(payload: Readonly<Record<string, unknown>>): Harness | null;
 //#endregion
 //#region src/harness/parse-payload.d.ts
-/**
- * Normalises one harness payload, or returns null when auto-mode has nothing to
- * say about it — an unknown harness, an event that is not a tool gate, or a
- * body that is not an object. A null is not a refusal: the caller stays out of
- * the way and the harness decides for itself.
- */
 export declare function parsePayload(body: unknown): HookPayload | null;
 //#endregion
 //#region src/harness/render-verdict.d.ts
-/**
- * Turns a verdict into the JSON the harness reads on stdout.
- *
- * All three harnesses take the same shape, because Codex and Muse both model
- * their hook contract on Claude's. `allow` and `ask` differ: `allow` runs the
- * tool with no prompt, while `ask` falls through to whatever the harness would
- * have done on its own, which is usually to ask the operator.
- */
 export declare function renderVerdict(event: HookEvent, verdict: Verdict): string;
 //#endregion
 //#region src/install/hook-config.d.ts
-/**
- * Prints the hook entry a harness needs, for the user to paste into their own
- * settings. auto-mode never writes those files itself: they are the user's
- * configuration, and an agent that can edit its own restraints has none.
- *
- * All three take a different entry shape, and each difference is load-bearing:
- *
- * - Claude matches tool names against a regular expression, so matching every
- *   tool is `.*`. Two near-misses both leave the hook installed but never
- *   firing: `*` is not a valid regular expression, and `""` matches only a tool
- *   whose name is the empty string.
- * - Muse takes `""` to mean every tool, so the same value means opposite things
- *   in the two harnesses.
- * - Codex registers a bare handler list with no matcher.
- * - Muse 1.3 rejects a handler carrying `timeout_ms`, reporting an unknown
- *   field and skipping the whole handler silently, so the hook never runs. A
- *   user-tier Muse entry takes `type` and `command` and nothing else.
- *
- * The timeout is 90 seconds, not the usual 30: a reasoning model takes 13-24
- * seconds on a hard case, and a harness timeout shorter than the model call
- * turns every hard case into a silent failure.
- */
-export declare function hookConfig(harness: Harness, command: string): string;
+export declare function buildHookConfig(harness: Harness, command: string): string;
 export declare const SETTINGS_PATHS: Readonly<Record<Harness, string>>;
 //#endregion
 //#region src/model/classify-with-model.d.ts
@@ -150,44 +62,19 @@ interface ModelOutcome {
   readonly verdict: Verdict | null;
   readonly note: string;
 }
-/**
- * Asks the model. A null verdict means auto-mode has no opinion, and the caller
- * writes nothing so the harness decides for itself.
- */
 export declare function classifyWithModel(payload: HookPayload, config: Config): Promise<ModelOutcome>;
 //#endregion
 //#region src/model/parse-verdict.d.ts
-/**
- * Reads the classifier's answer.
- *
- * Every ambiguity resolves to allow, on the policy's own reasoning: a block
- * nobody can name is a false positive, and a false positive costs more than the
- * action it stopped. A model that says `yes` but names no rule has not made a
- * case, so there is nothing to show the user and nothing to appeal.
- */
 export declare function parseModelVerdict(text: string): Verdict;
 //#endregion
 //#region src/policy/load-policy.d.ts
 interface PolicyPaths {
-  /** The framework: how to judge. Defaults to the shipped `policy/classifier.md`. */
-  readonly classifierPath?: string;
-  /** The rule list: what to judge against. Defaults to the shipped `policy/rules.md`. */
-  readonly rulesPath?: string;
+  readonly classifierPath?: string | undefined;
+  readonly rulesPath?: string | undefined;
 }
-/**
- * Reads the two policy files and splices them into the one system prompt the
- * model receives. Nothing else is added, so `auto-mode print-prompt` shows
- * exactly what the classifier reads.
- */
 export declare function loadPolicy(paths?: PolicyPaths): Promise<string>;
 //#endregion
 //#region src/rules/classify-locally.d.ts
-/**
- * What the local tier decides. It allows or it declines to decide. It never
- * denies: a wrong local allow costs one unwatched action, while a wrong local
- * deny stops work the user asked for, and the rules that deny are prose that
- * needs a reader.
- */
 type LocalVerdict = {
   readonly kind: 'allow';
   readonly exception: string;
@@ -197,23 +84,10 @@ type LocalVerdict = {
 export declare function classifyLocally(payload: HookPayload): LocalVerdict;
 //#endregion
 //#region src/transcript/read-transcript.d.ts
-/** One line of the conversation, flattened to text the classifier can read. */
 interface TranscriptEntry {
   readonly role: string;
   readonly text: string;
 }
-/**
- * Reads the tail of a harness transcript.
- *
- * Only the tail, and always the same tail for a given session length, so the
- * prompt prefix grows by appending rather than sliding. A sliding window would
- * change the cached prefix on every call and pay full price each time.
- *
- * Every harness writes JSONL but none writes the same schema, so this reads
- * defensively and drops what it cannot understand. A transcript it cannot parse
- * yields no entries, and the classifier then judges the action with no history —
- * which is weaker, not wrong.
- */
 export declare function readTranscript(path: string | undefined, limit: number): Promise<readonly TranscriptEntry[]>;
 //#endregion
 export type { Config, Harness, HookEvent, HookPayload, LocalVerdict, ModelOutcome, PolicyPaths, ProviderConfig, TranscriptEntry, Verdict };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as loadPolicy, c as hookConfig, d as detectHarness, f as DEFAULT_CONFIG, g as resolveApiKey, h as loadConfig, i as readTranscript, l as renderVerdict, m as configPath, n as classifyWithModel, o as SETTINGS_PATHS, p as PRESETS, r as parseModelVerdict, t as classifyLocally, u as parsePayload } from "./classify-locally-BHl0xiqa.js";
-export { DEFAULT_CONFIG, PRESETS, SETTINGS_PATHS, classifyLocally, classifyWithModel, configPath, detectHarness, hookConfig, loadConfig, loadPolicy, parseModelVerdict, parsePayload, readTranscript, renderVerdict, resolveApiKey };
+import { a as loadPolicy, c as buildHookConfig, d as detectHarness, f as DEFAULT_CONFIG, g as resolveConfigPath, h as resolveApiKey, i as readTranscript, l as renderVerdict, m as loadConfig, n as classifyWithModel, o as SETTINGS_PATHS, p as PRESETS, r as parseModelVerdict, t as classifyLocally, u as parsePayload } from "./classify-locally-rTUwxBZi.js";
+export { DEFAULT_CONFIG, PRESETS, SETTINGS_PATHS, buildHookConfig, classifyLocally, classifyWithModel, detectHarness, loadConfig, loadPolicy, parseModelVerdict, parsePayload, readTranscript, renderVerdict, resolveApiKey, resolveConfigPath };

package/package.json

@@ -1,23 +1,31 @@
 {
   "name": "auto-mode",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A permission classifier that runs as a hook, so agents that are not Claude can run unattended",
   "keywords": [
     "agent",
-    "hook",
-    "permissions",
     "claude-code",
     "codex",
-    "muse"
+    "hook",
+    "muse",
+    "permissions"
   ],
+  "homepage": "https://github.com/zgeoff/auto-mode#readme",
+  "bugs": "https://github.com/zgeoff/auto-mode/issues",
   "license": "MIT",
-  "type": "module",
-  "engines": {
-    "node": ">=24"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zgeoff/auto-mode.git"
   },
   "bin": {
     "auto-mode": "./dist/cli.js"
   },
+  "files": [
+    "dist",
+    "policy",
+    "LICENSE"
+  ],
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -26,30 +34,47 @@
     "./policy/classifier.md": "./policy/classifier.md",
     "./policy/rules.md": "./policy/rules.md"
   },
-  "files": [
-    "dist",
-    "policy",
-    "LICENSE"
-  ],
   "scripts": {
+    "audit": "bun audit",
     "build": "tsdown",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run --passWithNoTests",
+    "build:agents": "bash scripts/build-agents-md.sh agents/shared.md agents/project.md AGENTS.md",
+    "check": "bun run format:check && bun run lint && bun run typecheck && bun run deadcode && bun test && bun run build && bun run publint",
+    "deadcode": "knip",
+    "first-publish": "scripts/first-publish.sh",
+    "format": "oxfmt . && format-codemod --quiet .",
+    "format:check": "oxfmt --check . && format-codemod --check --quiet .",
+    "lint": "oxlint --type-aware --type-check --report-unused-disable-directives-severity error",
+    "lint:fix": "oxlint --type-aware --type-check --report-unused-disable-directives-severity error --fix",
+    "prepare": "command -v git > /dev/null 2>&1 && lefthook install --force || true",
     "publint": "publint",
-    "check": "npm run typecheck && npm run test && npm run build && npm run publint",
-    "first-publish": "scripts/first-publish.sh"
+    "test": "bun test",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "devDependencies": {
-    "@types/node": "^24.13.5",
-    "publint": "^0.3.24",
-    "tsdown": "^0.23.0",
-    "typescript": "^7.0.2",
-    "vitest": "^5.0.1"
+    "@commitlint/cli": "21.2.2",
+    "@faker-js/faker": "10.6.0",
+    "@stylistic/eslint-plugin": "5.10.0",
+    "@tsconfig/strictest": "2.0.8",
+    "@types/bun": "1.3.14",
+    "@types/node": "26.5.1",
+    "@zgeoff/bun-test-extended": "0.1.0",
+    "@zgeoff/format-codemod": "0.1.0",
+    "@zgeoff/oxlint-config": "0.1.0",
+    "knip": "6.35.1",
+    "lefthook": "2.1.12",
+    "msw": "2.15.0",
+    "oxfmt": "0.67.0",
+    "oxlint": "1.82.0",
+    "oxlint-tsgolint": "7.0.2001",
+    "publint": "0.3.24",
+    "tiny-invariant": "1.3.3",
+    "ts-pattern": "5.9.0",
+    "tsdown": "0.23.0",
+    "typescript": "7.0.2",
+    "zod": "4.6.2"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/zgeoff/auto-mode.git"
+  "engines": {
+    "node": ">=24"
   },
-  "homepage": "https://github.com/zgeoff/auto-mode#readme",
-  "bugs": "https://github.com/zgeoff/auto-mode/issues"
+  "packageManager": "bun@1.3.10"
 }