@aeriondyseti/claude-profiles 0.1.0-dev.9

package/README.md

@@ -0,0 +1,156 @@
+# claude-profiles
+
+CLI and interactive TUI for managing multiple [Claude Code](https://docs.anthropic.com/en/docs/claude-code) configuration profiles.
+
+Each profile is an isolated config directory (`~/.claude-<name>`) with its own `settings.json`, commands, hooks, agents, skills, and output styles. Switch between profiles by setting the `CLAUDE_CONFIG_DIR` environment variable.
+
+## Quick Start
+
+Run directly with npx (no install required):
+
+```sh
+npx @aeriondyseti/claude-profiles
+```
+
+This launches the interactive TUI. You can also run specific commands directly:
+
+```sh
+npx @aeriondyseti/claude-profiles list
+npx @aeriondyseti/claude-profiles create work
+npx @aeriondyseti/claude-profiles run work -- -p "hello"
+```
+
+## Install
+
+```sh
+# Global install (provides the `claude-profiles` command)
+npm install -g @aeriondyseti/claude-profiles
+
+# Or run without installing
+npx @aeriondyseti/claude-profiles
+```
+
+> **Note:** This tool requires [Bun](https://bun.sh) as its runtime.
+
+## Commands
+
+| Command | Aliases | Description |
+|---|---|---|
+| *(none)* | | Launch interactive TUI |
+| `list` | `ls` | List all profiles and their status |
+| `create [name]` | `new` | Create a new profile (optionally copy settings from an existing one) |
+| `edit [name]` | | Open a profile's `settings.json` in your `$EDITOR` |
+| `clone [source] [name]` | `cp` | Clone a profile's configuration (settings, commands, hooks, agents, skills, output styles) |
+| `delete [name]` | `rm` | Delete a profile (with confirmation) |
+| `switch [name]` | `use` | Print the `export` command and shell alias to activate a profile |
+| `run [name] [-- args]` | `exec` | Launch `claude` with a specific profile's config dir |
+| `bind [name] [path]` | | Bind a profile to a directory via `.claude-profile` |
+| `unbind [path]` | | Remove a `.claude-profile` binding from a directory |
+
+All commands accept an optional profile name argument. If omitted, an interactive prompt is shown.
+
+## Usage
+
+### Creating a profile
+
+```sh
+claude-profiles create work
+```
+
+This creates `~/.claude-work/` with a default `settings.json` that includes a session-start hook displaying the active profile name.
+
+During interactive creation, you can optionally copy settings from an existing profile.
+
+### Running Claude with a profile
+
+```sh
+# Via the run command
+claude-profiles run work
+
+# Pass extra arguments to Claude after --
+claude-profiles run work -- -p "summarize this file"
+
+# Or manually set the environment variable
+export CLAUDE_CONFIG_DIR=~/.claude-work
+claude
+```
+
+### Cloning a profile
+
+```sh
+claude-profiles clone work staging
+```
+
+Clones configuration files only — `settings.json`, `CLAUDE.md`, `commands/`, `hooks/`, `agents/`, `skills/`, and `output-styles/`. Auth state and session history are **not** copied.
+
+### Directory-aware profiles
+
+You can bind a profile to a directory so that `claude-profiles run` automatically uses it:
+
+```sh
+# Bind the "work" profile to the current directory
+claude-profiles bind work
+
+# Now run Claude without specifying a profile
+claude-profiles run
+# => Using profile 'work' (from /path/to/project/.claude-profile)
+```
+
+This writes a `.claude-profile` TOML file in the directory:
+
+```toml
+profile = "work"
+```
+
+The `run` command walks up from the current directory looking for this file. If found, it uses that profile automatically. If not found and no name is given, it falls back to the interactive prompt.
+
+To remove a binding:
+
+```sh
+claude-profiles unbind
+```
+
+### Shell alias for quick access
+
+`claude-profiles switch <name>` prints an alias you can add to your shell config:
+
+```sh
+alias claude-work='CLAUDE_CONFIG_DIR=~/.claude-work claude'
+```
+
+## How Profiles Work
+
+Claude Code uses the `CLAUDE_CONFIG_DIR` environment variable to locate its configuration directory. By default this is `~/.claude`. This tool creates and manages additional directories at `~/.claude-<name>`, each acting as a fully independent config root.
+
+The default profile (`~/.claude`) is recognized and listed but cannot be created or deleted through this tool.
+
+## Local Development
+
+Requires [Bun](https://bun.sh).
+
+```sh
+git clone https://github.com/aeriondyseti/claude-profiles.git
+cd claude-profiles
+bun install
+```
+
+Run locally:
+
+```sh
+# Interactive TUI
+bun src/cli.ts
+
+# Specific command
+bun src/cli.ts list
+bun src/cli.ts create my-profile
+```
+
+Typecheck:
+
+```sh
+bunx tsc --noEmit
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@aeriondyseti/claude-profiles",
+  "version": "0.1.0-dev.9",
+  "description": "TUI and CLI for managing Claude Code profiles",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "claude-profiles": "src/cli.ts"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "prepublishOnly": "bunx tsc --noEmit"
+  },
+  "keywords": [
+    "claude",
+    "cli",
+    "profiles",
+    "tui"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aeriondyseti/claude-profiles"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.10.0",
+    "smol-toml": "^1.6.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.11",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,108 @@
+#!/usr/bin/env bun
+
+import { main } from "./index.ts";
+import { listProfiles } from "./commands/list.ts";
+import { createProfileCommand } from "./commands/create.ts";
+import { editProfileCommand } from "./commands/edit.ts";
+import { cloneProfileCommand } from "./commands/clone.ts";
+import { deleteProfileCommand } from "./commands/delete.ts";
+import { switchProfileCommand } from "./commands/switch.ts";
+import { runProfileCommand } from "./commands/run.ts";
+import { bindProfileCommand } from "./commands/bind.ts";
+import { unbindCommand } from "./commands/unbind.ts";
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function run(): Promise<void> {
+  switch (command) {
+    case "list":
+    case "ls":
+      await listProfiles();
+      break;
+
+    case "create":
+    case "new":
+      await createProfileCommand(args[1]);
+      break;
+
+    case "edit":
+      await editProfileCommand(args[1]);
+      break;
+
+    case "clone":
+    case "cp":
+      await cloneProfileCommand(args[1], args[2]);
+      break;
+
+    case "delete":
+    case "rm":
+      await deleteProfileCommand(args[1]);
+      break;
+
+    case "switch":
+    case "use":
+      await switchProfileCommand(args[1]);
+      break;
+
+    case "run":
+    case "exec": {
+      const dashDash = args.indexOf("--");
+      const profileName = args[1];
+      const extraArgs = dashDash >= 0 ? args.slice(dashDash + 1) : [];
+      await runProfileCommand(profileName, extraArgs);
+      break;
+    }
+
+    case "bind":
+      await bindProfileCommand(args[1], args[2]);
+      break;
+
+    case "unbind":
+      await unbindCommand(args[1]);
+      break;
+
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      break;
+
+    case undefined:
+      // No command — launch interactive TUI
+      await main();
+      break;
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+function printHelp(): void {
+  console.log(`
+claude-profiles — Manage Claude Code profiles
+
+Usage:
+  claude-profiles                          Interactive TUI
+  claude-profiles list                     List all profiles
+  claude-profiles create [name]            Create a new profile
+  claude-profiles edit [name]              Edit profile settings.json
+  claude-profiles clone [source] [name]    Clone a profile
+  claude-profiles delete [name]            Delete a profile
+  claude-profiles switch [name]            Show how to activate a profile
+  claude-profiles run [name] [-- args]     Run Claude with a specific profile
+  claude-profiles bind [name] [path]       Bind a profile to a directory (.claude-profile)
+  claude-profiles unbind [path]            Remove .claude-profile from a directory
+
+Aliases:
+  ls = list, new = create, cp = clone,
+  rm = delete, use = switch, exec = run
+`);
+}
+
+run().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/commands/bind.ts

@@ -0,0 +1,54 @@
+import * as p from "@clack/prompts";
+import { writeFile, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { stringify } from "smol-toml";
+import { selectProfile } from "./shared.ts";
+import { profileExists } from "../profiles.ts";
+import { PROFILE_FILENAME } from "../detect.ts";
+
+function isCancel(value: unknown): value is symbol {
+  return p.isCancel(value);
+}
+
+export async function bindProfileCommand(
+  nameArg?: string,
+  pathArg?: string,
+): Promise<void> {
+  let profileName: string;
+
+  if (nameArg) {
+    if (!(await profileExists(nameArg))) {
+      p.log.error(`Profile "${nameArg}" does not exist.`);
+      return;
+    }
+    profileName = nameArg;
+  } else {
+    const profile = await selectProfile("Bind which profile to this directory?");
+    if (!profile) return;
+    profileName = profile.name;
+  }
+
+  const dir = resolve(pathArg ?? process.cwd());
+  const filePath = join(dir, PROFILE_FILENAME);
+
+  // Check if file already exists
+  const exists = await stat(filePath)
+    .then(() => true)
+    .catch(() => false);
+
+  if (exists && !nameArg) {
+    const overwrite = await p.confirm({
+      message: `${filePath} already exists. Overwrite?`,
+      initialValue: false,
+    });
+    if (isCancel(overwrite) || !overwrite) {
+      p.cancel("Cancelled.");
+      return;
+    }
+  }
+
+  const content = stringify({ profile: profileName });
+  await writeFile(filePath, content + "\n");
+
+  p.log.success(`Bound profile '${profileName}' to ${dir}`);
+}

package/src/commands/clone.ts

@@ -0,0 +1,45 @@
+import * as p from "@clack/prompts";
+import { cloneProfile } from "../profiles.ts";
+import { selectProfile } from "./shared.ts";
+
+function isCancel(value: unknown): value is symbol {
+  return p.isCancel(value);
+}
+
+export async function cloneProfileCommand(
+  sourceArg?: string,
+  nameArg?: string,
+): Promise<void> {
+  const source = await selectProfile("Which profile to clone?", sourceArg);
+  if (!source) return;
+
+  let name = nameArg;
+  if (!name) {
+    const input = await p.text({
+      message: "New profile name:",
+      placeholder: `e.g. ${source.name}-copy`,
+      validate(value) {
+        if (!value.trim()) return "Name is required";
+        if (!/^[a-zA-Z0-9_-]+$/.test(value))
+          return "Name must be alphanumeric (hyphens and underscores allowed)";
+        return undefined;
+      },
+    });
+    if (isCancel(input)) {
+      p.cancel("Cancelled.");
+      return;
+    }
+    name = input;
+  }
+
+  try {
+    const dir = await cloneProfile(source.dir, name);
+    p.log.success(`Cloned "${source.name}" → "${name}" at ${dir}`);
+    p.log.info(
+      "Cloned: settings.json, CLAUDE.md, commands/, hooks/, agents/, skills/, output-styles/",
+    );
+    p.log.info("Excluded: sessions, history, auth state (.claude.json)");
+  } catch (err) {
+    p.log.error(String(err));
+  }
+}

package/src/commands/create.ts

@@ -0,0 +1,80 @@
+import * as p from "@clack/prompts";
+import { createProfile, getAllProfiles, readSettings, defaultSettings } from "../profiles.ts";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+function isCancel(value: unknown): value is symbol {
+  return p.isCancel(value);
+}
+
+export async function createProfileCommand(nameArg?: string): Promise<void> {
+  let name = nameArg;
+
+  if (!name) {
+    const input = await p.text({
+      message: "Profile name:",
+      placeholder: "e.g. work, personal, testing",
+      validate(value) {
+        if (!value.trim()) return "Name is required";
+        if (!/^[a-zA-Z0-9_-]+$/.test(value))
+          return "Name must be alphanumeric (hyphens and underscores allowed)";
+        return undefined;
+      },
+    });
+    if (isCancel(input)) {
+      p.cancel("Cancelled.");
+      return;
+    }
+    name = input;
+  }
+
+  const profiles = await getAllProfiles();
+
+  let copyFrom: string | null = null;
+  if (profiles.length > 0) {
+    const copy = await p.select({
+      message: "Copy settings from an existing profile?",
+      options: [
+        { value: "__none__", label: "No, start fresh" },
+        ...profiles.map((prof) => ({
+          value: prof.dir,
+          label: prof.name,
+        })),
+      ],
+    });
+    if (isCancel(copy)) {
+      p.cancel("Cancelled.");
+      return;
+    }
+    if (copy !== "__none__") {
+      copyFrom = copy as string;
+    }
+  }
+
+  const dir = await createProfile(name);
+
+  if (copyFrom) {
+    const settings = await readSettings(copyFrom);
+    if (settings) {
+      const defaults = defaultSettings(name);
+      const merged = {
+        ...settings,
+        hooks: {
+          ...((settings.hooks as Record<string, unknown>) ?? {}),
+          ...((defaults.hooks as Record<string, unknown>) ?? {}),
+        },
+      };
+      await writeFile(
+        join(dir, "settings.json"),
+        JSON.stringify(merged, null, 2) + "\n",
+      );
+    }
+  }
+
+  p.log.success(
+    `Created profile "${name}" at ${dir}`,
+  );
+  p.log.info(
+    `Run with: CLAUDE_CONFIG_DIR=${dir} claude`,
+  );
+}

package/src/commands/delete.ts

@@ -0,0 +1,37 @@
+import * as p from "@clack/prompts";
+import { deleteProfile } from "../profiles.ts";
+import { isActiveProfile, DEFAULT_PROFILE_NAME } from "../utils.ts";
+import { selectProfile } from "./shared.ts";
+
+function isCancel(value: unknown): value is symbol {
+  return p.isCancel(value);
+}
+
+export async function deleteProfileCommand(nameArg?: string): Promise<void> {
+  const profile = await selectProfile("Which profile to delete?", nameArg);
+  if (!profile) return;
+
+  if (profile.name === DEFAULT_PROFILE_NAME) {
+    p.log.error(`Cannot delete the default profile.`);
+    return;
+  }
+
+  if (isActiveProfile(profile.dir)) {
+    p.log.error(
+      `Cannot delete "${profile.name}" — it is the currently active profile.`,
+    );
+    return;
+  }
+
+  const confirmed = await p.confirm({
+    message: `Delete profile "${profile.name}"? This will remove ${profile.dir} and all its contents.`,
+    initialValue: false,
+  });
+  if (isCancel(confirmed) || !confirmed) {
+    p.cancel("Cancelled.");
+    return;
+  }
+
+  await deleteProfile(profile.dir);
+  p.log.success(`Deleted profile "${profile.name}".`);
+}

package/src/commands/edit.ts

@@ -0,0 +1,21 @@
+import * as p from "@clack/prompts";
+import { execSync } from "node:child_process";
+import { join } from "node:path";
+import { selectProfile } from "./shared.ts";
+
+export async function editProfileCommand(nameArg?: string): Promise<void> {
+  const profile = await selectProfile("Which profile to edit?", nameArg);
+  if (!profile) return;
+
+  const settingsPath = join(profile.dir, "settings.json");
+  const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+
+  p.log.info(`Opening ${settingsPath} in ${editor}...`);
+
+  try {
+    execSync(`${editor} "${settingsPath}"`, { stdio: "inherit" });
+    p.log.success("Settings updated.");
+  } catch {
+    p.log.error("Editor exited with an error.");
+  }
+}

package/src/commands/list.ts

@@ -0,0 +1,29 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { getAllProfiles } from "../profiles.ts";
+import { isActiveProfile } from "../utils.ts";
+
+export async function listProfiles(): Promise<void> {
+  const profiles = await getAllProfiles();
+
+  if (profiles.length === 0) {
+    p.log.warn("No profiles found. Create one with `claude-profiles create`.");
+    return;
+  }
+
+  p.log.info(pc.bold("Claude Code Profiles"));
+
+  for (const profile of profiles) {
+    const active = isActiveProfile(profile.dir);
+    const marker = active ? pc.green("●") : pc.dim("○");
+    const name = active ? pc.green(pc.bold(profile.name)) : profile.name;
+    const details: string[] = [];
+    if (profile.email) details.push(profile.email);
+    // Only show org name if it's not just the email repeated
+    if (profile.orgName && !profile.orgName.includes(profile.email ?? ""))
+      details.push(profile.orgName);
+    const detailStr = details.length > 0 ? pc.dim(` (${details.join(" — ")})`) : "";
+
+    p.log.message(`${marker} ${name}${detailStr}`);
+  }
+}

package/src/commands/run.ts

@@ -0,0 +1,44 @@
+import * as p from "@clack/prompts";
+import { execFileSync } from "node:child_process";
+import { selectProfile } from "./shared.ts";
+import { detectProfile } from "../detect.ts";
+
+export async function runProfileCommand(
+  nameArg?: string,
+  extraArgs: string[] = [],
+): Promise<void> {
+  let effectiveName = nameArg;
+
+  if (!effectiveName) {
+    const detected = await detectProfile();
+    if (detected) {
+      p.log.info(
+        `Using profile '${detected.name}' (from ${detected.filePath})`,
+      );
+      effectiveName = detected.name;
+    }
+  }
+
+  const profile = await selectProfile("Run Claude with which profile?", effectiveName);
+  if (!profile) return;
+
+  const claudeCmd = "claude";
+  p.log.info(
+    `Running: CLAUDE_CONFIG_DIR=${profile.dir} ${claudeCmd} ${extraArgs.join(" ")}`,
+  );
+
+  try {
+    execFileSync(claudeCmd, extraArgs, {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        CLAUDE_CONFIG_DIR: profile.dir,
+      },
+    });
+  } catch (err: unknown) {
+    const code = (err as { status?: number }).status;
+    if (code !== null && code !== undefined) {
+      process.exit(code);
+    }
+  }
+}

package/src/commands/shared.ts

@@ -0,0 +1,45 @@
+import * as p from "@clack/prompts";
+import { getAllProfiles, type ProfileInfo } from "../profiles.ts";
+import { formatProfileOption } from "../utils.ts";
+
+function isCancel(value: unknown): value is symbol {
+  return p.isCancel(value);
+}
+
+export async function selectProfile(
+  message: string,
+  nameArg?: string,
+): Promise<ProfileInfo | null> {
+  const profiles = await getAllProfiles();
+
+  if (profiles.length === 0) {
+    p.log.warn("No profiles found. Create one first.");
+    return null;
+  }
+
+  if (nameArg) {
+    const match = profiles.find((prof) => prof.name === nameArg);
+    if (!match) {
+      p.log.error(
+        `Profile "${nameArg}" not found. Available: ${profiles.map((p) => p.name).join(", ")}`,
+      );
+      return null;
+    }
+    return match;
+  }
+
+  const selected = await p.select({
+    message,
+    options: profiles.map((prof) => ({
+      value: prof.dir,
+      label: formatProfileOption(prof.dir, prof.email),
+    })),
+  });
+
+  if (isCancel(selected)) {
+    p.cancel("Cancelled.");
+    return null;
+  }
+
+  return profiles.find((prof) => prof.dir === selected) ?? null;
+}

package/src/commands/switch.ts

@@ -0,0 +1,19 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { selectProfile } from "./shared.ts";
+
+export async function switchProfileCommand(nameArg?: string): Promise<void> {
+  const profile = await selectProfile("Switch to which profile?", nameArg);
+  if (!profile) return;
+
+  p.log.info("To activate this profile, run:");
+  p.log.message(
+    pc.cyan(`export CLAUDE_CONFIG_DIR=${profile.dir}`),
+  );
+  p.log.info("Or add an alias to your shell config:");
+  p.log.message(
+    pc.cyan(
+      `alias claude-${profile.name}='CLAUDE_CONFIG_DIR=${profile.dir} claude'`,
+    ),
+  );
+}