claude-code-modes 0.1.0

package/src/config-cli.ts

@@ -0,0 +1,320 @@
+import { writeFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { parseArgs } from "node:util";
+import {
+  type UserConfig,
+  readConfigFile,
+  checkModifierNameCollision,
+  checkPresetNameCollision,
+  checkAxisValueCollision,
+} from "./config.js";
+import { AXIS_BUILTINS } from "./types.js";
+const VALID_AXES = Object.keys(AXIS_BUILTINS) as Array<"agency" | "quality" | "scope">;
+type ValidAxis = (typeof VALID_AXES)[number];
+
+function getConfigPath(isGlobal: boolean): string {
+  if (isGlobal) {
+    return join(homedir(), ".config", "claude-mode", "config.json");
+  }
+  return join(process.cwd(), ".claude-mode.json");
+}
+
+function configFileName(configPath: string): string {
+  // Return a user-friendly name for confirmation messages
+  const home = homedir();
+  if (configPath.startsWith(home)) {
+    return "~" + configPath.slice(home.length);
+  }
+  return configPath.split("/").pop() ?? configPath;
+}
+
+function readConfig(configPath: string): UserConfig {
+  if (!existsSync(configPath)) return {};
+  return readConfigFile(configPath);
+}
+
+function writeConfig(configPath: string, config: UserConfig): void {
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+function configShow(configPath: string): void {
+  if (!existsSync(configPath)) {
+    process.stdout.write("No config file found.\n");
+    return;
+  }
+  const text = readFileSync(configPath, "utf8");
+  process.stdout.write(text.trimEnd() + "\n");
+}
+
+function configInit(configPath: string): void {
+  if (existsSync(configPath)) {
+    throw new Error(`Config file already exists: ${configPath}`);
+  }
+  const scaffold: UserConfig = {
+    defaultModifiers: [],
+    modifiers: {},
+    axes: {},
+    presets: {},
+  };
+  writeConfig(configPath, scaffold);
+  process.stdout.write(`Created ${configFileName(configPath)}\n`);
+}
+
+function configAddDefault(configPath: string, value: string): void {
+  const config = readConfig(configPath);
+  const defaults = config.defaultModifiers ?? [];
+  if (defaults.includes(value)) {
+    process.stdout.write(
+      `"${value}" is already in defaultModifiers in ${configFileName(configPath)}\n`
+    );
+    return;
+  }
+  config.defaultModifiers = [...defaults, value];
+  writeConfig(configPath, config);
+  process.stdout.write(
+    `Added "${value}" to defaultModifiers in ${configFileName(configPath)}\n`
+  );
+}
+
+function configRemoveDefault(configPath: string, value: string): void {
+  const config = readConfig(configPath);
+  const defaults = config.defaultModifiers ?? [];
+  if (!defaults.includes(value)) {
+    throw new Error(
+      `"${value}" not found in defaultModifiers in ${configFileName(configPath)}`
+    );
+  }
+  config.defaultModifiers = defaults.filter((v) => v !== value);
+  writeConfig(configPath, config);
+  process.stdout.write(
+    `Removed "${value}" from defaultModifiers in ${configFileName(configPath)}\n`
+  );
+}
+
+function configAddModifier(configPath: string, name: string, mdPath: string): void {
+  checkModifierNameCollision(name);
+  const config = readConfig(configPath);
+  config.modifiers = { ...config.modifiers, [name]: mdPath };
+  writeConfig(configPath, config);
+  process.stdout.write(
+    `Registered modifier "${name}" in ${configFileName(configPath)}\n`
+  );
+}
+
+function configRemoveModifier(configPath: string, name: string): void {
+  const config = readConfig(configPath);
+  const modifiers = config.modifiers ?? {};
+  if (!(name in modifiers)) {
+    throw new Error(
+      `Modifier "${name}" not found in ${configFileName(configPath)}`
+    );
+  }
+  const updated = { ...modifiers };
+  delete updated[name];
+  config.modifiers = updated;
+  writeConfig(configPath, config);
+  process.stdout.write(
+    `Unregistered modifier "${name}" from ${configFileName(configPath)}\n`
+  );
+}
+
+function configAddAxis(configPath: string, axis: string, name: string, mdPath: string): void {
+  if (!VALID_AXES.includes(axis as ValidAxis)) {
+    throw new Error(
+      `Invalid axis "${axis}"; must be one of: ${VALID_AXES.join(", ")}`
+    );
+  }
+  const validAxis = axis as ValidAxis;
+
+  checkAxisValueCollision(validAxis, name);
+
+  const config = readConfig(configPath);
+  config.axes = config.axes ?? {};
+  config.axes[validAxis] = { ...config.axes[validAxis], [name]: mdPath };
+  writeConfig(configPath, config);
+  process.stdout.write(
+    `Registered ${axis} value "${name}" in ${configFileName(configPath)}\n`
+  );
+}
+
+function configRemoveAxis(configPath: string, axis: string, name: string): void {
+  if (!VALID_AXES.includes(axis as ValidAxis)) {
+    throw new Error(
+      `Invalid axis "${axis}"; must be one of: ${VALID_AXES.join(", ")}`
+    );
+  }
+  const validAxis = axis as ValidAxis;
+
+  const config = readConfig(configPath);
+  const axisMap = config.axes?.[validAxis] ?? {};
+  if (!(name in axisMap)) {
+    throw new Error(
+      `${axis} value "${name}" not found in ${configFileName(configPath)}`
+    );
+  }
+  const updated = { ...axisMap };
+  delete updated[name];
+  config.axes = config.axes ?? {};
+  config.axes[validAxis] = updated;
+  writeConfig(configPath, config);
+  process.stdout.write(
+    `Unregistered ${axis} value "${name}" from ${configFileName(configPath)}\n`
+  );
+}
+
+function configAddPreset(configPath: string, name: string, flags: string[]): void {
+  checkPresetNameCollision(name);
+
+  const { values } = parseArgs({
+    args: flags,
+    options: {
+      agency: { type: "string" },
+      quality: { type: "string" },
+      scope: { type: "string" },
+      modifier: { type: "string", multiple: true },
+      readonly: { type: "boolean" },
+      "context-pacing": { type: "boolean" },
+    },
+    strict: true,
+  });
+
+  const presetDef: NonNullable<UserConfig["presets"]>[string] = {};
+  if (values.agency !== undefined) presetDef.agency = values.agency;
+  if (values.quality !== undefined) presetDef.quality = values.quality;
+  if (values.scope !== undefined) presetDef.scope = values.scope;
+  if (values.modifier !== undefined && values.modifier.length > 0) {
+    presetDef.modifiers = values.modifier as string[];
+  }
+  if (values.readonly !== undefined) presetDef.readonly = values.readonly;
+  if (values["context-pacing"] !== undefined) presetDef.contextPacing = values["context-pacing"];
+
+  const config = readConfig(configPath);
+  config.presets = { ...config.presets, [name]: presetDef };
+  writeConfig(configPath, config);
+  process.stdout.write(
+    `Created preset "${name}" in ${configFileName(configPath)}\n`
+  );
+}
+
+function configRemovePreset(configPath: string, name: string): void {
+  const config = readConfig(configPath);
+  const presets = config.presets ?? {};
+  if (!(name in presets)) {
+    throw new Error(
+      `Preset "${name}" not found in ${configFileName(configPath)}`
+    );
+  }
+  const updated = { ...presets };
+  delete updated[name];
+  config.presets = updated;
+  writeConfig(configPath, config);
+  process.stdout.write(
+    `Removed preset "${name}" from ${configFileName(configPath)}\n`
+  );
+}
+
+/**
+ * Handles `claude-mode config <subcommand> [args] [--global]`.
+ * Defaults to project-local (.claude-mode.json in CWD).
+ * --global targets ~/.config/claude-mode/config.json.
+ */
+export function runConfigCommand(argv: string[]): void {
+  // Extract --global flag
+  const isGlobal = argv.includes("--global");
+  const args = argv.filter((a) => a !== "--global");
+
+  const configPath = getConfigPath(isGlobal);
+  const [subcommand, ...rest] = args;
+
+  if (!subcommand || subcommand === "help") {
+    const usage = `Usage: claude-mode config <subcommand> [args] [--global]
+
+Subcommands:
+  show                              Print current config
+  init                              Create .claude-mode.json scaffold
+  add-default <name-or-path>        Add to defaultModifiers
+  remove-default <name>             Remove from defaultModifiers
+  add-modifier <name> <path>        Register a named modifier
+  remove-modifier <name>            Unregister a named modifier
+  add-axis <axis> <name> <path>     Register custom axis value
+  remove-axis <axis> <name>         Unregister custom axis value
+  add-preset <name> [flags]         Create a custom preset
+  remove-preset <name>              Remove a custom preset
+
+Flags for add-preset:
+  --agency <value>
+  --quality <value>
+  --scope <value>
+  --modifier <name> (repeatable)
+  --readonly
+  --context-pacing`;
+    process.stdout.write(usage + "\n");
+    return;
+  }
+
+  switch (subcommand) {
+    case "show":
+      configShow(configPath);
+      break;
+
+    case "init":
+      configInit(configPath);
+      break;
+
+    case "add-default": {
+      if (rest.length < 1) throw new Error("add-default requires <name-or-path>");
+      configAddDefault(configPath, rest[0]);
+      break;
+    }
+
+    case "remove-default": {
+      if (rest.length < 1) throw new Error("remove-default requires <name>");
+      configRemoveDefault(configPath, rest[0]);
+      break;
+    }
+
+    case "add-modifier": {
+      if (rest.length < 2) throw new Error("add-modifier requires <name> <path>");
+      configAddModifier(configPath, rest[0], rest[1]);
+      break;
+    }
+
+    case "remove-modifier": {
+      if (rest.length < 1) throw new Error("remove-modifier requires <name>");
+      configRemoveModifier(configPath, rest[0]);
+      break;
+    }
+
+    case "add-axis": {
+      if (rest.length < 3) throw new Error("add-axis requires <axis> <name> <path>");
+      configAddAxis(configPath, rest[0], rest[1], rest[2]);
+      break;
+    }
+
+    case "remove-axis": {
+      if (rest.length < 2) throw new Error("remove-axis requires <axis> <name>");
+      configRemoveAxis(configPath, rest[0], rest[1]);
+      break;
+    }
+
+    case "add-preset": {
+      if (rest.length < 1) throw new Error("add-preset requires <name>");
+      const [presetName, ...presetFlags] = rest;
+      configAddPreset(configPath, presetName, presetFlags);
+      break;
+    }
+
+    case "remove-preset": {
+      if (rest.length < 1) throw new Error("remove-preset requires <name>");
+      configRemovePreset(configPath, rest[0]);
+      break;
+    }
+
+    default:
+      throw new Error(
+        `Unknown config subcommand: "${subcommand}". Run "claude-mode config help" for usage.`
+      );
+  }
+}

package/src/config.ts

@@ -0,0 +1,300 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname, resolve, isAbsolute } from "node:path";
+import { homedir } from "node:os";
+import { PRESET_NAMES, BUILTIN_MODIFIER_NAMES, AXIS_BUILTINS, BUILTIN_BASE_NAMES, isBuiltinModifier, isPresetName, isBuiltinBase, isBuiltinAxisValue } from "./types.js";
+
+/** Matches paths that reference potentially sensitive files (SSH keys, credentials, etc.) */
+const SUSPICIOUS_PATH_PATTERN = /\.(ssh|env|gnupg|aws|kube|docker|pgpass)|\.npmrc|\.netrc|id_rsa|id_ed25519|id_ecdsa|credentials|secret|token|password|private/i;
+
+/**
+ * Validates a file path defined in a config file.
+ * Config-defined paths must end with .md and must not reference sensitive files.
+ * This prevents malicious .claude-mode.json files from exfiltrating secrets.
+ */
+function validateConfigDefinedPath(path: string, context: string, configPath: string): void {
+  if (!path.endsWith(".md")) {
+    throw new Error(
+      `Invalid config file ${configPath}: ${context} must be a .md file, got "${path}"`
+    );
+  }
+  if (SUSPICIOUS_PATH_PATTERN.test(path)) {
+    throw new Error(
+      `Invalid config file ${configPath}: ${context} references a potentially sensitive path "${path}"`
+    );
+  }
+}
+
+/** Schema for .claude-mode.json */
+export interface UserConfig {
+  defaultBase?: string;
+  bases?: Record<string, string>; // name → directory path (relative to config dir)
+  defaultModifiers?: string[];
+  modifiers?: Record<string, string>;
+  axes?: {
+    agency?: Record<string, string>;
+    quality?: Record<string, string>;
+    scope?: Record<string, string>;
+  };
+  presets?: Record<string, CustomPresetDef>;
+}
+
+export interface CustomPresetDef {
+  base?: string; // base name for this preset
+  agency?: string;
+  quality?: string;
+  scope?: string;
+  modifiers?: string[];
+  readonly?: boolean;
+  contextPacing?: boolean;
+}
+
+export interface LoadedConfig {
+  config: UserConfig;
+  configDir: string; // directory the config file lives in, for resolving relative paths
+}
+
+/** Throws if name collides with a built-in modifier name. */
+export function checkModifierNameCollision(name: string): void {
+  if (isBuiltinModifier(name)) {
+    throw new Error(
+      `"${name}" is a built-in modifier name (${BUILTIN_MODIFIER_NAMES.join(", ")}); choose a different name`
+    );
+  }
+}
+
+/** Throws if name collides with a built-in preset name. */
+export function checkPresetNameCollision(name: string): void {
+  if (isPresetName(name)) {
+    throw new Error(
+      `"${name}" is a built-in preset name (${PRESET_NAMES.join(", ")}); choose a different name`
+    );
+  }
+}
+
+/** Throws if name collides with a built-in base name. */
+export function checkBaseNameCollision(name: string): void {
+  if (isBuiltinBase(name)) {
+    throw new Error(
+      `"${name}" is a built-in base name (${BUILTIN_BASE_NAMES.join(", ")}); choose a different name`
+    );
+  }
+}
+
+/** Throws if name collides with a built-in value for the given axis. */
+export function checkAxisValueCollision(axis: "agency" | "quality" | "scope", name: string): void {
+  const builtins = AXIS_BUILTINS[axis];
+  if (isBuiltinAxisValue(axis, name)) {
+    throw new Error(
+      `"${name}" is a built-in ${axis} value (${builtins.join(", ")}); choose a different name`
+    );
+  }
+}
+
+/**
+ * Reads and parses a config file, checking only that the top-level value is an object.
+ * Does NOT run full schema validation — callers that need full validation should use loadConfig().
+ * Throws on invalid JSON or non-object top-level value.
+ */
+export function readConfigFile(configPath: string): UserConfig {
+  let raw: unknown;
+  try {
+    const text = readFileSync(configPath, "utf8");
+    raw = JSON.parse(text);
+  } catch (err) {
+    throw new Error(
+      `Invalid config file ${configPath}: ${(err as Error).message}`
+    );
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error(
+      `Invalid config file ${configPath}: top-level value must be an object`
+    );
+  }
+  return raw as UserConfig;
+}
+
+/**
+ * Loads config from .claude-mode.json in CWD, falling back to
+ * ~/.config/claude-mode/config.json. Returns null if neither exists.
+ * Throws on invalid JSON or schema violations.
+ */
+export function loadConfig(): LoadedConfig | null {
+  const candidates = [
+    join(process.cwd(), ".claude-mode.json"),
+    join(homedir(), ".config", "claude-mode", "config.json"),
+  ];
+
+  for (const configPath of candidates) {
+    if (!existsSync(configPath)) continue;
+
+    const config = validateConfig(readConfigFile(configPath), configPath);
+    return { config, configDir: dirname(configPath) };
+  }
+
+  return null;
+}
+
+/** Validates a value is a Record<string, string>. Returns the typed record or throws. */
+function validateStringRecord(
+  value: unknown,
+  fieldName: string,
+  configPath: string,
+): Record<string, string> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(
+      `Invalid config file ${configPath}: "${fieldName}" must be an object (Record<string, string>)`
+    );
+  }
+  const record = value as Record<string, unknown>;
+  for (const [key, val] of Object.entries(record)) {
+    if (typeof val !== "string") {
+      throw new Error(
+        `Invalid config file ${configPath}: "${fieldName}.${key}" must be a string`
+      );
+    }
+  }
+  return record as Record<string, string>;
+}
+
+/** Validates a value is a string[]. Returns the typed array or throws. */
+function validateStringArray(
+  value: unknown,
+  fieldName: string,
+  configPath: string,
+): string[] {
+  if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+    throw new Error(
+      `Invalid config file ${configPath}: "${fieldName}" must be an array of strings`
+    );
+  }
+  return value as string[];
+}
+
+/**
+ * Validates the loaded config object. Throws descriptive errors for:
+ * - Non-object top-level value
+ * - Invalid field types
+ * - Custom preset names that collide with built-in preset names
+ * - Custom modifier names that collide with built-in modifier names
+ */
+function validateConfig(raw: unknown, configPath: string): UserConfig {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error(
+      `Invalid config file ${configPath}: top-level value must be an object`
+    );
+  }
+
+  const obj = raw as Record<string, unknown>;
+
+  // Validate defaultBase
+  if (obj.defaultBase !== undefined && typeof obj.defaultBase !== "string") {
+    throw new Error(
+      `Invalid config file ${configPath}: "defaultBase" must be a string`
+    );
+  }
+
+  // Validate bases map
+  if (obj.bases !== undefined) {
+    const bases = validateStringRecord(obj.bases, "bases", configPath);
+    for (const key of Object.keys(bases)) checkBaseNameCollision(key);
+  }
+
+  // Validate defaultModifiers
+  if (obj.defaultModifiers !== undefined) {
+    const defaultModifiers = validateStringArray(obj.defaultModifiers, "defaultModifiers", configPath);
+    // Validate file path entries in defaultModifiers
+    for (const entry of defaultModifiers) {
+      if (entry.includes("/") || entry.includes("\\") || entry.endsWith(".md")) {
+        validateConfigDefinedPath(entry, `"defaultModifiers" entry "${entry}"`, configPath);
+      }
+    }
+  }
+
+  // Validate modifiers map
+  if (obj.modifiers !== undefined) {
+    const modifiers = validateStringRecord(obj.modifiers, "modifiers", configPath);
+    for (const [key, val] of Object.entries(modifiers)) {
+      checkModifierNameCollision(key);
+      validateConfigDefinedPath(val, `"modifiers.${key}"`, configPath);
+    }
+  }
+
+  // Validate axes
+  if (obj.axes !== undefined) {
+    if (typeof obj.axes !== "object" || obj.axes === null || Array.isArray(obj.axes)) {
+      throw new Error(
+        `Invalid config file ${configPath}: "axes" must be an object`
+      );
+    }
+    const axesObj = obj.axes as Record<string, unknown>;
+    for (const axisName of ["agency", "quality", "scope"] as const) {
+      if (axesObj[axisName] !== undefined) {
+        const axisMap = validateStringRecord(axesObj[axisName], `axes.${axisName}`, configPath);
+        for (const [key, val] of Object.entries(axisMap)) {
+          validateConfigDefinedPath(val, `"axes.${axisName}.${key}"`, configPath);
+        }
+      }
+    }
+  }
+
+  // Validate presets
+  if (obj.presets !== undefined) {
+    if (typeof obj.presets !== "object" || obj.presets === null || Array.isArray(obj.presets)) {
+      throw new Error(
+        `Invalid config file ${configPath}: "presets" must be an object`
+      );
+    }
+    for (const [presetName, presetDef] of Object.entries(obj.presets as Record<string, unknown>)) {
+      checkPresetNameCollision(presetName);
+      if (typeof presetDef !== "object" || presetDef === null || Array.isArray(presetDef)) {
+        throw new Error(
+          `Invalid config file ${configPath}: preset "${presetName}" must be an object`
+        );
+      }
+      const def = presetDef as Record<string, unknown>;
+      if (def.base !== undefined && typeof def.base !== "string") {
+        throw new Error(
+          `Invalid config file ${configPath}: preset "${presetName}.base" must be a string`
+        );
+      }
+      for (const field of ["agency", "quality", "scope"] as const) {
+        if (def[field] !== undefined && typeof def[field] !== "string") {
+          throw new Error(
+            `Invalid config file ${configPath}: preset "${presetName}.${field}" must be a string`
+          );
+        }
+      }
+      if (def.modifiers !== undefined) {
+        if (
+          !Array.isArray(def.modifiers) ||
+          !def.modifiers.every((v) => typeof v === "string")
+        ) {
+          throw new Error(
+            `Invalid config file ${configPath}: preset "${presetName}.modifiers" must be an array of strings`
+          );
+        }
+      }
+      if (def.readonly !== undefined && typeof def.readonly !== "boolean") {
+        throw new Error(
+          `Invalid config file ${configPath}: preset "${presetName}.readonly" must be a boolean`
+        );
+      }
+      if (def.contextPacing !== undefined && typeof def.contextPacing !== "boolean") {
+        throw new Error(
+          `Invalid config file ${configPath}: preset "${presetName}.contextPacing" must be a boolean`
+        );
+      }
+    }
+  }
+
+  return raw as UserConfig;
+}
+
+/**
+ * Resolves a path from the config file relative to the config file's directory.
+ * Absolute paths are returned as-is.
+ */
+export function resolveConfigPath(configDir: string, relativePath: string): string {
+  if (isAbsolute(relativePath)) return relativePath;
+  return resolve(configDir, relativePath);
+}