auto-mode 0.8.0 → 0.9.0

package/README.md

@@ -38,7 +38,7 @@ Create the classifier configuration:
 
 Save it as `~/.config/auto-mode/config.json` and export your TypeSafe API key, or set the entry's
 `apiKeyCommand` to a command that prints it. [Configuration](./docs/guides/configuration.md) covers
-the registries, credentials, and migrating an older file.
+the registries and credentials.
 
 ## Standing permissions
 
@@ -77,7 +77,6 @@ fit.
 | `auto-mode run --local-only` | Skip the model tier                       |
 | `auto-mode run --jev-only`   | Require Jev with a 5-second API timeout   |
 | `auto-mode print-prompt`     | Print the selected provider's base policy |
-| `auto-mode config migrate`   | Rewrite an older config file in place     |
 
 The mod evaluates only ask decisions and preserves existing allow and deny decisions. It runs the
 CLI as a bounded child process with `--jev-only`. The `spark`, `claude`, `glm`, and `messages`

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { _ as string, f as resolveConfigPath, g as strictObject, h as number, l as DEFAULT_DENIAL_BUDGET, n as parseActionRequest, p as normalizeConfigFile, r as classifyAction, s as loadPolicy, t as renderVerdict, u as loadConfig } from "./render-verdict-DePMDXKz.js";
-import { appendFile, constants, copyFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { g as string, h as strictObject, l as DEFAULT_DENIAL_BUDGET, m as number, n as parseActionRequest, r as classifyAction, s as loadPolicy, t as renderVerdict, u as loadConfig } from "./render-verdict-CK9sRJpa.js";
+import { appendFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
@@ -154,36 +154,6 @@ function buildJevOnlyConfig(config) {
 	};
 }
 //#endregion
-//#region src/config/write-migrated-config.ts
-async function writeMigratedConfig(path) {
-	let raw;
-	try {
-		raw = await readFile(path, "utf8");
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return `${path} does not exist; nothing to migrate`;
-		throw new Error(`${path} is unreadable`, { cause: error });
-	}
-	let json;
-	try {
-		json = JSON.parse(raw);
-	} catch {
-		throw new Error(`${path} is not valid JSON`);
-	}
-	const normalized = normalizeConfigFile(json, path);
-	if (!normalized.isLegacy) return `${path} already uses the current shape`;
-	const backup = `${path}.bak`;
-	const staged = `${path}.migrating`;
-	try {
-		await copyFile(path, backup, constants.COPYFILE_EXCL);
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "EEXIST") throw new Error(`${backup} already exists; move it aside and run the migration again`, { cause: error });
-		throw error;
-	}
-	await writeFile(staged, `${JSON.stringify(normalized.file, null, 2)}\n`, { mode: 384 });
-	await rename(staged, path);
-	return `rewrote ${path} in the current shape; the old file is at ${backup}`;
-}
-//#endregion
 //#region src/diagnostics/write-action-diagnostic.ts
 async function writeActionDiagnostic(payload, entry) {
 	const path = process.env["AUTO_MODE_DIAGNOSTICS_PATH"] ?? join(resolveStateDir(), "actions.jsonl");
@@ -221,7 +191,6 @@ const USAGE = `auto-mode — a permission classifier for the auto-mode Claude Co
 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 config migrate   Rewrite the config file from the old keys into the current shape
 
 Options:
   --classifier <path>   Use this framework file instead of the shipped one
@@ -381,21 +350,9 @@ async function main(argv) {
 		process.stdout.write(`${prompt}\n`);
 		return 0;
 	}
-	if (command === "config" && args.positionals[1] === "migrate") return runConfigMigration();
 	process.stderr.write(`auto-mode: unknown command '${command}'\n\n${USAGE}`);
 	return 2;
 }
-async function runConfigMigration() {
-	const path = resolveConfigPath();
-	try {
-		const result = await writeMigratedConfig(path);
-		process.stdout.write(`${result}\n`);
-		return 0;
-	} catch (error) {
-		process.stderr.write(`auto-mode: ${error instanceof Error ? error.message : "config migration failed"}\n`);
-		return 1;
-	}
-}
 process.exitCode = await main(process.argv.slice(2));
 //#endregion
 export {};

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as classifyWithModel, c as DEFAULT_CONFIG, d as resolveApiKey, f as resolveConfigPath, i as classifyLocally, m as PRESETS, n as parseActionRequest, o as parseModelVerdict, r as classifyAction, s as loadPolicy, t as renderVerdict, u as loadConfig } from "./render-verdict-DePMDXKz.js";
+import { a as classifyWithModel, c as DEFAULT_CONFIG, d as resolveApiKey, f as resolveConfigPath, i as classifyLocally, n as parseActionRequest, o as parseModelVerdict, p as PRESETS, r as classifyAction, s as loadPolicy, t as renderVerdict, u as loadConfig } from "./render-verdict-CK9sRJpa.js";
 export { DEFAULT_CONFIG, PRESETS, classifyAction, classifyLocally, classifyWithModel, loadConfig, loadPolicy, parseActionRequest, parseModelVerdict, renderVerdict, resolveApiKey, resolveConfigPath };

package/dist/{render-verdict-DePMDXKz.js → render-verdict-CK9sRJpa.js}

@@ -5615,126 +5615,6 @@ function findPreset(id) {
 	return Object.hasOwn(PRESETS, id) ? PRESETS[id] : void 0;
 }
 //#endregion
-//#region src/config/normalize-config-file.ts
-function normalizeConfigFile(json, path) {
-	if (!isRecord(json)) return {
-		file: json,
-		isLegacy: false,
-		warnings: []
-	};
-	const legacyKeys = Object.keys(json).filter((key) => LEGACY_KEYS.has(key));
-	if (legacyKeys.length === 0) return {
-		file: json,
-		isLegacy: false,
-		warnings: []
-	};
-	const currentKeys = Object.keys(json).filter((key) => !LEGACY_KEYS.has(key));
-	if (currentKeys.length > 0) throw new Error(`${path} mixes the old keys (${legacyKeys.join(", ")}) with the new ones (${currentKeys.join(", ")}); run \`auto-mode config migrate\` on a copy without the new keys`);
-	const parsed = legacyConfigSchema.safeParse(json);
-	if (!parsed.success) throw new Error(`${path} is not a valid config: ${prettifyError(parsed.error)}`);
-	const legacy = parsed.data;
-	const warnings = [`${path} uses the old config keys (${legacyKeys.join(", ")}); run \`auto-mode config migrate\` to rewrite it`, ...legacy.transcriptEntries === void 0 ? [] : [`${path} sets transcriptEntries, which has no effect; migration drops it`]];
-	return {
-		file: buildFileFromLegacy(legacy, path),
-		isLegacy: true,
-		warnings
-	};
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-const LEGACY_KEYS = /* @__PURE__ */ new Set([
-	"preset",
-	"provider",
-	"classifierPath",
-	"rulesPath",
-	"transcriptEntries",
-	"onFailure",
-	"claudeSettingsPath",
-	"minConfidence"
-]);
-const text$1 = string().min(1);
-const positive$1 = number().positive();
-const legacyConfigSchema = strictObject({
-	preset: text$1.optional(),
-	provider: strictObject({
-		protocol: _enum(["messages", "system-one"]).optional(),
-		baseURL: text$1.optional(),
-		model: text$1.optional(),
-		apiKeyEnv: text$1.optional(),
-		apiKeyCommand: text$1.optional(),
-		reasoning: boolean().optional(),
-		maxTokens: positive$1.optional(),
-		timeoutMs: positive$1.optional()
-	}).optional(),
-	classifierPath: text$1.optional(),
-	rulesPath: text$1.optional(),
-	transcriptEntries: number().nonnegative().optional(),
-	onFailure: _enum(["defer", "deny"]).optional(),
-	claudeSettingsPath: text$1.nullable().optional(),
-	minConfidence: number().min(.5).max(1).optional()
-});
-function buildFileFromLegacy(legacy, path) {
-	const hasClassifier = legacy.preset !== void 0 || legacy.provider !== void 0;
-	const decision = {
-		...hasClassifier ? { classifier: getLegacyClassifierID(legacy) } : {},
-		...legacy.minConfidence === void 0 ? {} : { minConfidence: legacy.minConfidence },
-		...legacy.onFailure === void 0 ? {} : { onFailure: legacy.onFailure }
-	};
-	const policy = {
-		...legacy.rulesPath === void 0 ? {} : { rulesPath: legacy.rulesPath },
-		...legacy.classifierPath === void 0 ? {} : { frameworkPath: legacy.classifierPath },
-		...legacy.claudeSettingsPath === void 0 ? {} : { claudeSettingsPath: legacy.claudeSettingsPath }
-	};
-	return {
-		...hasClassifier ? { classifiers: { [getLegacyClassifierID(legacy)]: buildClassifierEntry(getLegacyClassifierID(legacy), buildLegacyProvider(legacy, path)) } } : {},
-		...Object.keys(decision).length === 0 ? {} : { decision },
-		...Object.keys(policy).length === 0 ? {} : { policy }
-	};
-}
-function getLegacyClassifierID(legacy) {
-	if (legacy.preset !== void 0) return legacy.preset;
-	return legacy.provider !== void 0 && legacy.provider.protocol !== "system-one" ? "spark" : "jev";
-}
-function buildLegacyProvider(legacy, path) {
-	const preset = findPreset(getLegacyClassifierID(legacy));
-	if (preset === void 0) throw new Error(`${path} names an unknown preset '${legacy.preset}'; known presets are ${Object.keys(PRESETS).join(", ")}`);
-	const override = legacy.provider ?? {};
-	return {
-		protocol: override.protocol ?? preset.protocol ?? "messages",
-		baseURL: override.baseURL ?? preset.baseURL,
-		model: override.model ?? preset.model,
-		apiKeyEnv: override.apiKeyEnv ?? preset.apiKeyEnv,
-		apiKeyCommand: override.apiKeyCommand ?? preset.apiKeyCommand,
-		reasoning: override.reasoning ?? preset.reasoning,
-		maxTokens: override.maxTokens ?? preset.maxTokens,
-		timeoutMs: override.timeoutMs ?? preset.timeoutMs
-	};
-}
-const PROVIDER_FIELDS = [
-	"baseURL",
-	"model",
-	"apiKeyEnv",
-	"apiKeyCommand",
-	"reasoning",
-	"maxTokens",
-	"timeoutMs"
-];
-function buildClassifierEntry(id, provider) {
-	const kind = pickEntryKind(id, provider);
-	const base = kind === "messages" ? MESSAGES_DEFAULTS : findPreset(kind) ?? {};
-	const fields = Object.fromEntries(PROVIDER_FIELDS.filter((field) => provider[field] !== void 0 && provider[field] !== base[field]).map((field) => [field, provider[field]]));
-	return {
-		...kind === id ? {} : { kind },
-		...fields
-	};
-}
-function pickEntryKind(id, provider) {
-	const preset = findPreset(id);
-	if (preset !== void 0 && (preset.protocol ?? "messages") === provider.protocol) return id;
-	return provider.protocol === "system-one" ? "jev" : "messages";
-}
-//#endregion
 //#region src/config/read-api-key-from-command.ts
 function readApiKeyFromCommand(command, options = {}) {
 	const remainingMs = options.deadlineAt === void 0 ? 5e3 : options.deadlineAt - Date.now();
@@ -5826,8 +5706,7 @@ async function loadConfig(path = resolveConfigPath()) {
 	} catch {
 		throw new Error(`${path} is not valid JSON`);
 	}
-	const normalized = normalizeConfigFile(json, path);
-	return buildConfig(normalized.file, path, normalized.warnings);
+	return buildConfig(json, path);
 }
 const text = string().min(1);
 const positive = number().positive();
@@ -5851,11 +5730,11 @@ const configFileSchema = strictObject({
 		claudeSettingsPath: text.nullable().optional()
 	}).optional()
 });
-function buildConfig(json, path, legacyWarnings) {
+function buildConfig(json, path) {
 	const parsed = configFileSchema.safeParse(json);
 	if (!parsed.success) throw new Error(`${path} is not a valid config: ${prettifyError(parsed.error)}`);
 	const file = parsed.data;
-	const warnings = [...legacyWarnings];
+	const warnings = [];
 	const classifiers = buildRegistry(file.classifiers ?? {}, (id, entry) => parseClassifierEntry(id, entry));
 	const scopeSources = buildRegistry(file.scopeSources ?? {}, (id, entry) => parseScopeSourceEntry(id, entry));
 	warnings.push(...classifiers.dropped.map((line) => `${path}: classifiers.${line}`), ...scopeSources.dropped.map((line) => `${path}: scopeSources.${line}`));
@@ -7318,4 +7197,4 @@ function renderVerdict(verdict) {
 	})).exhaustive();
 }
 //#endregion
-export { string as _, classifyWithModel as a, DEFAULT_CONFIG as c, resolveApiKey as d, resolveConfigPath as f, strictObject as g, number as h, classifyLocally as i, DEFAULT_DENIAL_BUDGET as l, PRESETS as m, parseActionRequest as n, parseModelVerdict as o, normalizeConfigFile as p, classifyAction as r, loadPolicy as s, renderVerdict as t, loadConfig as u };
+export { classifyWithModel as a, DEFAULT_CONFIG as c, resolveApiKey as d, resolveConfigPath as f, string as g, strictObject as h, classifyLocally as i, DEFAULT_DENIAL_BUDGET as l, number as m, parseActionRequest as n, parseModelVerdict as o, PRESETS as p, classifyAction as r, loadPolicy as s, renderVerdict as t, loadConfig as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-mode",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "A permission classifier library and Claude Code mod, so agents that are not Claude can run unattended",
   "keywords": [
     "agent",