@panchr/tyr 0.1.0

package/src/commands/config.ts

@@ -0,0 +1,181 @@
+import { defineCommand } from "citty";
+import {
+	getConfigPath,
+	getEnvPath,
+	isValidKey,
+	parseValue,
+	readConfig,
+	readEnvFile,
+	readRawConfig,
+	writeConfig,
+	writeEnvVar,
+} from "../config.ts";
+import { type TyrConfig, TyrConfigSchema } from "../types.ts";
+
+const show = defineCommand({
+	meta: {
+		name: "show",
+		description: "Display current configuration",
+	},
+	async run() {
+		const config = await readConfig().catch((err) => {
+			console.error(
+				`Invalid config: ${err instanceof Error ? err.message : err}`,
+			);
+			return process.exit(1) as never;
+		});
+		console.log(JSON.stringify(config, null, 2));
+	},
+});
+
+const set = defineCommand({
+	meta: {
+		name: "set",
+		description:
+			"Set a configuration value (e.g. tyr config set failOpen true)",
+	},
+	args: {
+		key: { type: "positional", description: "Config key", required: true },
+		value: { type: "positional", description: "Config value", required: true },
+	},
+	async run({ args }) {
+		const key = args.key as string;
+		const value = args.value as string;
+
+		if (!isValidKey(key)) {
+			console.error(`Unknown config key: ${key}`);
+			process.exit(1);
+			return;
+		}
+
+		const parsed = parseValue(key, value);
+		if (parsed === null) {
+			console.error(`Invalid value for ${key}: ${value}`);
+			process.exit(1);
+			return;
+		}
+
+		const raw = await readRawConfig().catch((err) => {
+			console.error(
+				`Cannot read config: ${err instanceof Error ? err.message : err}`,
+			);
+			return process.exit(1) as never;
+		});
+		const parts = key.split(".");
+		if (parts.length === 2) {
+			const group = parts[0] as string;
+			const field = parts[1] as string;
+			if (!raw[group] || typeof raw[group] !== "object") raw[group] = {};
+			(raw[group] as Record<string, unknown>)[field] = parsed;
+		} else {
+			raw[key] = parsed;
+		}
+
+		let config: TyrConfig;
+		try {
+			config = TyrConfigSchema.strict().parse(raw);
+		} catch (err) {
+			console.error(
+				`Config would still be invalid after this change: ${err instanceof Error ? err.message : err}`,
+			);
+			process.exit(1);
+			return;
+		}
+		await writeConfig(config);
+		console.log(`Set ${key} = ${String(parsed)}`);
+	},
+});
+
+const path = defineCommand({
+	meta: {
+		name: "path",
+		description: "Print the config file path",
+	},
+	run() {
+		console.log(getConfigPath());
+	},
+});
+
+function maskValue(value: string): string {
+	if (value.length <= 4) return "****";
+	return `${value.slice(0, 4)}...`;
+}
+
+const envSet = defineCommand({
+	meta: {
+		name: "set",
+		description:
+			"Set an environment variable (e.g. tyr config env set KEY VALUE)",
+	},
+	args: {
+		key: { type: "positional", description: "Variable name", required: true },
+		value: {
+			type: "positional",
+			description: "Variable value",
+			required: true,
+		},
+	},
+	run({ args }) {
+		const key = args.key as string;
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+			console.error(`Invalid variable name: ${key}`);
+			process.exit(1);
+			return;
+		}
+		writeEnvVar(key, args.value as string);
+		console.log(`Set ${key} in ${getEnvPath()}`);
+	},
+});
+
+const envShow = defineCommand({
+	meta: {
+		name: "show",
+		description: "Show environment variables (values masked)",
+	},
+	run() {
+		const vars = readEnvFile();
+		const entries = Object.entries(vars);
+		if (entries.length === 0) {
+			console.log("No environment variables set.");
+			return;
+		}
+		for (const [key, value] of entries) {
+			console.log(`${key}=${maskValue(value)}`);
+		}
+	},
+});
+
+const envPath = defineCommand({
+	meta: {
+		name: "path",
+		description: "Print the env file path",
+	},
+	run() {
+		console.log(getEnvPath());
+	},
+});
+
+const env = defineCommand({
+	meta: {
+		name: "env",
+		description: "Manage environment variables in tyr's .env file",
+	},
+	subCommands: {
+		set: envSet,
+		show: envShow,
+		path: envPath,
+	},
+});
+
+export default defineCommand({
+	meta: {
+		name: "config",
+		description: "View and manage tyr configuration",
+	},
+	subCommands: {
+		show,
+		set,
+		path,
+		env,
+	},
+});

package/src/commands/db.ts

@@ -0,0 +1,66 @@
+import { defineCommand } from "citty";
+import {
+	CURRENT_SCHEMA_VERSION,
+	getDbPath,
+	getSchemaVersion,
+	hasMetaTable,
+	openRawDb,
+	runMigrations,
+} from "../db.ts";
+
+const migrate = defineCommand({
+	meta: {
+		name: "migrate",
+		description: "Run pending database schema migrations",
+	},
+	async run() {
+		const dbPath = getDbPath();
+		const db = openRawDb(dbPath);
+
+		if (!hasMetaTable(db)) {
+			console.log(
+				"Database is uninitialized. Run any tyr command to create the schema.",
+			);
+			db.close();
+			return;
+		}
+
+		const version = getSchemaVersion(db);
+		if (version === null) {
+			console.error(
+				"[tyr] database is missing schema_version. Cannot migrate.",
+			);
+			db.close();
+			process.exit(1);
+		}
+
+		if (version === CURRENT_SCHEMA_VERSION) {
+			console.log(
+				`Database is already at v${CURRENT_SCHEMA_VERSION}. Nothing to do.`,
+			);
+			db.close();
+			return;
+		}
+
+		console.log(`Database: ${dbPath}`);
+		console.log(`Current version: v${version}`);
+		console.log(`Target version:  v${CURRENT_SCHEMA_VERSION}`);
+
+		const result = runMigrations(db);
+		console.log(
+			`Applied ${result.applied} migration(s): v${result.fromVersion} → v${result.toVersion}`,
+		);
+
+		db.close();
+	},
+});
+
+export default defineCommand({
+	meta: {
+		name: "db",
+		description: "Database management commands",
+	},
+	subCommands: {
+		migrate,
+	},
+});

package/src/commands/debug.ts

@@ -0,0 +1,34 @@
+import { defineCommand } from "citty";
+import { ClaudeAgent } from "../agents/claude.ts";
+
+const claudeConfig = defineCommand({
+	meta: {
+		name: "claude-config",
+		description: "Print the merged Claude Code permission config",
+	},
+	args: {
+		cwd: {
+			type: "string",
+			description: "Project directory (defaults to current directory)",
+		},
+	},
+	async run({ args }) {
+		const cwd = (args.cwd as string | undefined) ?? process.cwd();
+		const agent = new ClaudeAgent();
+		await agent.init(cwd);
+		const info = agent.getDebugInfo();
+		agent.close();
+
+		console.log(JSON.stringify(info, null, 2));
+	},
+});
+
+export default defineCommand({
+	meta: {
+		name: "debug",
+		description: "Debugging and diagnostic tools",
+	},
+	subCommands: {
+		"claude-config": claudeConfig,
+	},
+});

package/src/commands/install.ts

@@ -0,0 +1,77 @@
+import { defineCommand } from "citty";
+import { rejectUnknownArgs } from "../args.ts";
+import type { JudgeMode } from "../install.ts";
+import {
+	getSettingsPath,
+	isInstalled,
+	mergeHook,
+	readSettings,
+	writeSettings,
+} from "../install.ts";
+
+const installArgs = {
+	global: {
+		type: "boolean" as const,
+		description: "Write to ~/.claude/settings.json",
+	},
+	project: {
+		type: "boolean" as const,
+		description: "Write to .claude/settings.json (default)",
+	},
+	"dry-run": {
+		type: "boolean" as const,
+		description: "Print what would be written without modifying anything",
+	},
+	shadow: {
+		type: "boolean" as const,
+		description: "Install in shadow mode (run pipeline but always abstain)",
+	},
+	audit: {
+		type: "boolean" as const,
+		description:
+			"Install in audit mode (log requests without running pipeline)",
+	},
+};
+
+export default defineCommand({
+	meta: {
+		name: "install",
+		description: "Register tyr as a Claude Code hook",
+	},
+	args: installArgs,
+	async run({ args, rawArgs }) {
+		rejectUnknownArgs(rawArgs, installArgs);
+
+		if (args.shadow && args.audit) {
+			console.error("--shadow and --audit are mutually exclusive");
+			process.exit(1);
+			return;
+		}
+
+		const scope = args.global ? "global" : "project";
+		const dryRun = args["dry-run"] ?? false;
+		const mode: JudgeMode = args.shadow
+			? "shadow"
+			: args.audit
+				? "audit"
+				: undefined;
+		const settingsPath = getSettingsPath(scope);
+
+		const settings = await readSettings(settingsPath);
+		const alreadyInstalled = isInstalled(settings);
+		const updated = mergeHook(settings, mode);
+
+		if (dryRun) {
+			console.log(`Would write to ${settingsPath}:\n`);
+			console.log(JSON.stringify(updated, null, 2));
+			return;
+		}
+
+		await writeSettings(settingsPath, updated);
+		if (alreadyInstalled) {
+			console.log(`Updated tyr hook in ${settingsPath}`);
+		} else {
+			console.log(`Installed tyr hook in ${settingsPath}`);
+		}
+	},
+});