claude-switch-profile 1.0.1

package/bin/csp.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+import { currentCommand } from '../src/commands/current.js';
+import { listCommand } from '../src/commands/list.js';
+import { createCommand } from '../src/commands/create.js';
+import { saveCommand } from '../src/commands/save.js';
+import { useCommand } from '../src/commands/use.js';
+import { deleteCommand } from '../src/commands/delete.js';
+import { exportCommand } from '../src/commands/export.js';
+import { importCommand } from '../src/commands/import.js';
+import { diffCommand } from '../src/commands/diff.js';
+import { initCommand } from '../src/commands/init.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+
+const program = new Command();
+
+program
+  .name('csp')
+  .description('Claude Switch Profile — manage multiple Claude Code configurations')
+  .version(pkg.version);
+
+program
+  .command('init')
+  .description('Initialize profiles directory and create default profile')
+  .action(initCommand);
+
+program
+  .command('current')
+  .description('Show the active profile')
+  .action(currentCommand);
+
+program
+  .command('list')
+  .alias('ls')
+  .description('List all profiles')
+  .action(listCommand);
+
+program
+  .command('create <name>')
+  .description('Create a new profile from current Claude Code state')
+  .option('--from <profile>', 'Clone from an existing profile')
+  .option('-s, --source <path>', 'Path to .agents/ or kit directory to link')
+  .option('-d, --description <text>', 'Profile description')
+  .action(createCommand);
+
+program
+  .command('save')
+  .description('Save current state to the active profile')
+  .action(saveCommand);
+
+program
+  .command('use <name>')
+  .description('Switch to a different profile')
+  .option('--dry-run', 'Show what would change without executing')
+  .option('--no-save', 'Skip saving current profile before switching')
+  .option('--force', 'Switch even if symlink targets are missing')
+  .action(useCommand);
+
+program
+  .command('delete <name>')
+  .alias('rm')
+  .description('Delete a profile')
+  .option('-f, --force', 'Skip confirmation prompt')
+  .action(deleteCommand);
+
+program
+  .command('export <name>')
+  .description('Export a profile as tar.gz archive')
+  .option('-o, --output <path>', 'Output file path')
+  .action(exportCommand);
+
+program
+  .command('import <file>')
+  .description('Import a profile from tar.gz archive')
+  .option('-n, --name <name>', 'Profile name (defaults to filename)')
+  .option('-d, --description <text>', 'Profile description')
+  .action(importCommand);
+
+program
+  .command('diff <profileA> <profileB>')
+  .description('Compare two profiles (use "current" for active profile)')
+  .action(diffCommand);
+
+program.parse();

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "claude-switch-profile",
+  "version": "1.0.1",
+  "description": "CLI tool for managing multiple Claude Code profiles",
+  "type": "module",
+  "bin": {
+    "csp": "./bin/csp.js"
+  },
+  "scripts": {
+    "test": "node --test tests/*.test.js",
+    "test:core": "node --test tests/core-library.test.js",
+    "test:cli": "node --test tests/cli-integration.test.js",
+    "test:safety": "node --test tests/safety.test.js",
+    "release": "node scripts/release.js",
+    "release:patch": "node scripts/release.js patch",
+    "release:minor": "node scripts/release.js minor",
+    "release:major": "node scripts/release.js major"
+  },
+  "keywords": [
+    "claude",
+    "profile",
+    "switcher",
+    "cli"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3"
+  }
+}

package/scripts/release.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * Release script for claude-switch-profile (csp)
+ * Usage: node scripts/release.js [patch|minor|major]
+ * Default: patch
+ */
+
+import { execSync } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..');
+const PKG_PATH = join(ROOT, 'package.json');
+
+const run = (cmd) => execSync(cmd, { cwd: ROOT, stdio: 'inherit' });
+const runQuiet = (cmd) => execSync(cmd, { cwd: ROOT, encoding: 'utf-8' }).trim();
+
+// --- Helpers ---
+
+const bumpVersion = (current, type) => {
+  const [major, minor, patch] = current.split('.').map(Number);
+  const bumps = {
+    major: `${major + 1}.0.0`,
+    minor: `${major}.${minor + 1}.0`,
+    patch: `${major}.${minor}.${patch + 1}`,
+  };
+  return bumps[type] || bumps.patch;
+};
+
+const checkCleanWorkingTree = () => {
+  const status = runQuiet('git status --porcelain');
+  if (status) {
+    console.error('✗ Working tree is not clean. Commit or stash changes first.');
+    console.error(status);
+    process.exit(1);
+  }
+};
+
+const checkOnMainBranch = () => {
+  const branch = runQuiet('git branch --show-current');
+  if (branch !== 'main' && branch !== 'master') {
+    console.error(`✗ Must be on main/master branch. Current: ${branch}`);
+    process.exit(1);
+  }
+};
+
+const checkNpmAuth = () => {
+  try {
+    runQuiet('npm whoami');
+  } catch {
+    console.error('✗ Not logged in to npm. Run "npm login" first.');
+    process.exit(1);
+  }
+};
+
+// --- Main ---
+
+const main = () => {
+  const type = process.argv[2] || 'patch';
+  if (!['patch', 'minor', 'major'].includes(type)) {
+    console.error(`✗ Invalid bump type: "${type}". Use patch, minor, or major.`);
+    process.exit(1);
+  }
+
+  // Pre-flight checks
+  console.log('Pre-flight checks...');
+  checkCleanWorkingTree();
+  checkOnMainBranch();
+  checkNpmAuth();
+  console.log('✓ All checks passed\n');
+
+  // Read current version
+  const pkg = JSON.parse(readFileSync(PKG_PATH, 'utf-8'));
+  const oldVersion = pkg.version;
+  const newVersion = bumpVersion(oldVersion, type);
+
+  console.log(`Bumping version: ${oldVersion} → ${newVersion} (${type})\n`);
+
+  // Run tests
+  console.log('Running tests...');
+  run('npm test');
+  console.log('✓ Tests passed\n');
+
+  // Update package.json version
+  pkg.version = newVersion;
+  writeFileSync(PKG_PATH, JSON.stringify(pkg, null, 2) + '\n');
+  console.log(`✓ Updated package.json to ${newVersion}`);
+
+  // Git commit + tag
+  run('git add package.json');
+  run(`git commit -m "chore(release): v${newVersion}"`);
+  run(`git tag -a v${newVersion} -m "v${newVersion}"`);
+  console.log(`✓ Created tag v${newVersion}`);
+
+  // Publish to npm
+  console.log('\nPublishing to npm...');
+  run('npm publish');
+  console.log(`✓ Published claude-switch-profile@${newVersion}`);
+
+  // Push to remote
+  run('git push && git push --tags');
+  console.log(`✓ Pushed to remote with tags\n`);
+
+  console.log(`🎉 Released v${newVersion} successfully!`);
+};
+
+main();

package/src/commands/create.js

@@ -0,0 +1,72 @@
+import { mkdirSync, cpSync, existsSync, writeFileSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { addProfile, getActive, setActive, profileExists, getProfileDir } from '../profile-store.js';
+import { saveSymlinks } from '../symlink-manager.js';
+import { saveFiles } from '../file-operations.js';
+import { SYMLINK_ITEMS, SOURCE_FILE } from '../constants.js';
+import { success, error, info, warn } from '../output-helpers.js';
+
+export const createCommand = (name, options) => {
+  if (profileExists(name)) {
+    error(`Profile "${name}" already exists.`);
+    process.exit(1);
+  }
+
+  const profileDir = getProfileDir(name);
+
+  if (options.from) {
+    // Clone from existing profile
+    if (!profileExists(options.from)) {
+      error(`Source profile "${options.from}" does not exist.`);
+      process.exit(1);
+    }
+    const sourceDir = getProfileDir(options.from);
+    cpSync(sourceDir, profileDir, { recursive: true });
+    info(`Cloned from profile "${options.from}"`);
+  } else if (options.source) {
+    // Create from a specific .agents/ directory (or any kit directory)
+    const sourcePath = resolve(options.source);
+    if (!existsSync(sourcePath)) {
+      error(`Source directory "${options.source}" does not exist.`);
+      process.exit(1);
+    }
+
+    mkdirSync(profileDir, { recursive: true });
+
+    // Build source.json from the kit directory
+    const sourceMap = {};
+    for (const item of SYMLINK_ITEMS) {
+      const target = join(sourcePath, item);
+      if (existsSync(target)) {
+        sourceMap[item] = target;
+      }
+    }
+
+    if (Object.keys(sourceMap).length === 0) {
+      warn(`No recognized items found in "${sourcePath}". Expected: ${SYMLINK_ITEMS.join(', ')}`);
+    }
+
+    writeFileSync(join(profileDir, SOURCE_FILE), JSON.stringify(sourceMap, null, 2) + '\n');
+    info(`Linked to kit at ${sourcePath}`);
+    info(`Items found: ${Object.keys(sourceMap).join(', ') || 'none'}`);
+
+    // Also copy current mutable files
+    saveFiles(profileDir);
+  } else {
+    // Create from current ~/.claude state
+    mkdirSync(profileDir, { recursive: true });
+    saveSymlinks(profileDir);
+    saveFiles(profileDir);
+    info('Captured current Claude Code configuration');
+  }
+
+  addProfile(name, { description: options.description || '' });
+
+  // Set as active if first profile
+  if (!getActive()) {
+    setActive(name);
+    info(`Set "${name}" as active profile`);
+  }
+
+  success(`Profile "${name}" created at ${profileDir}`);
+};

package/src/commands/current.js

@@ -0,0 +1,13 @@
+import { getActive } from '../profile-store.js';
+import { getProfileDir } from '../profile-store.js';
+import { success, info, warn } from '../output-helpers.js';
+
+export const currentCommand = () => {
+  const active = getActive();
+  if (!active) {
+    warn('No active profile. Run "csp create <name>" to create one.');
+    return;
+  }
+  success(`Active profile: ${active}`);
+  info(`Location: ${getProfileDir(active)}`);
+};

package/src/commands/delete.js

@@ -0,0 +1,40 @@
+import { rmSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { getActive, removeProfile, profileExists, getProfileDir } from '../profile-store.js';
+import { success, error, warn } from '../output-helpers.js';
+
+const confirm = (question) => {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith('y'));
+    });
+  });
+};
+
+export const deleteCommand = async (name, options) => {
+  if (!profileExists(name)) {
+    error(`Profile "${name}" does not exist.`);
+    process.exit(1);
+  }
+
+  const active = getActive();
+  if (active === name) {
+    error(`Cannot delete active profile "${name}". Switch to another profile first.`);
+    process.exit(1);
+  }
+
+  if (!options.force) {
+    const confirmed = await confirm(`Delete profile "${name}"? This cannot be undone. (y/N) `);
+    if (!confirmed) {
+      warn('Cancelled.');
+      return;
+    }
+  }
+
+  const profileDir = getProfileDir(name);
+  rmSync(profileDir, { recursive: true, force: true });
+  removeProfile(name);
+  success(`Profile "${name}" deleted.`);
+};

package/src/commands/diff.js

@@ -0,0 +1,119 @@
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { profileExists, getProfileDir, getActive } from '../profile-store.js';
+import { SOURCE_FILE } from '../constants.js';
+import { error, info } from '../output-helpers.js';
+
+export const diffCommand = (profileA, profileB) => {
+  // Resolve "current" alias
+  const resolveProfile = (name) => {
+    if (name === 'current') {
+      const active = getActive();
+      if (!active) {
+        error('No active profile to use as "current".');
+        process.exit(1);
+      }
+      return active;
+    }
+    return name;
+  };
+
+  const nameA = resolveProfile(profileA);
+  const nameB = resolveProfile(profileB);
+
+  if (!profileExists(nameA)) {
+    error(`Profile "${nameA}" does not exist.`);
+    process.exit(1);
+  }
+  if (!profileExists(nameB)) {
+    error(`Profile "${nameB}" does not exist.`);
+    process.exit(1);
+  }
+
+  const dirA = getProfileDir(nameA);
+  const dirB = getProfileDir(nameB);
+
+  console.log(`\n${chalk.bold('Comparing:')} ${chalk.cyan(nameA)} ↔ ${chalk.cyan(nameB)}\n`);
+
+  // Compare source.json (symlink targets)
+  const sourceA = readJsonSafe(join(dirA, SOURCE_FILE));
+  const sourceB = readJsonSafe(join(dirB, SOURCE_FILE));
+  diffObject('Symlink targets (source.json)', sourceA, sourceB, nameA, nameB);
+
+  // Compare files that exist in either profile
+  const filesA = new Set(readdirSync(dirA).filter((f) => f !== SOURCE_FILE));
+  const filesB = new Set(readdirSync(dirB).filter((f) => f !== SOURCE_FILE));
+
+  const allFiles = new Set([...filesA, ...filesB]);
+  const diffs = [];
+
+  for (const file of allFiles) {
+    const inA = filesA.has(file);
+    const inB = filesB.has(file);
+
+    if (inA && !inB) {
+      diffs.push({ file, status: `only in ${nameA}` });
+    } else if (!inA && inB) {
+      diffs.push({ file, status: `only in ${nameB}` });
+    } else {
+      // Both exist — compare content for regular files
+      const pathA = join(dirA, file);
+      const pathB = join(dirB, file);
+      try {
+        const contentA = readFileSync(pathA, 'utf-8');
+        const contentB = readFileSync(pathB, 'utf-8');
+        if (contentA !== contentB) {
+          diffs.push({ file, status: 'different' });
+        }
+      } catch {
+        diffs.push({ file, status: 'could not compare (directory?)' });
+      }
+    }
+  }
+
+  if (diffs.length === 0) {
+    info('Profiles are identical (excluding symlink targets).');
+  } else {
+    console.log(chalk.bold('File differences:'));
+    for (const d of diffs) {
+      const color = d.status === 'different' ? chalk.yellow : chalk.dim;
+      console.log(`  ${color(d.file)} — ${d.status}`);
+    }
+  }
+
+  console.log('');
+};
+
+const readJsonSafe = (path) => {
+  try {
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  } catch {
+    return {};
+  }
+};
+
+const diffObject = (label, objA, objB, nameA, nameB) => {
+  const allKeys = new Set([...Object.keys(objA), ...Object.keys(objB)]);
+  const diffs = [];
+
+  for (const key of allKeys) {
+    const valA = objA[key];
+    const valB = objB[key];
+    if (valA !== valB) {
+      diffs.push({ key, a: valA || '(none)', b: valB || '(none)' });
+    }
+  }
+
+  if (diffs.length === 0) {
+    info(`${label}: identical`);
+    return;
+  }
+
+  console.log(chalk.bold(`${label}:`));
+  for (const d of diffs) {
+    console.log(`  ${chalk.dim(d.key)}:`);
+    console.log(`    ${chalk.red(`${nameA}:`)} ${d.a}`);
+    console.log(`    ${chalk.green(`${nameB}:`)} ${d.b}`);
+  }
+};

package/src/commands/export.js

@@ -0,0 +1,24 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { profileExists, getProfileDir } from '../profile-store.js';
+import { success, error } from '../output-helpers.js';
+
+export const exportCommand = (name, options) => {
+  if (!profileExists(name)) {
+    error(`Profile "${name}" does not exist.`);
+    process.exit(1);
+  }
+
+  const profileDir = getProfileDir(name);
+  const output = options.output || `./${name}.csp.tar.gz`;
+  const outputPath = resolve(output);
+
+  try {
+    execFileSync('tar', ['-czf', outputPath, '-C', profileDir, '.'], { stdio: 'pipe' });
+    success(`Profile "${name}" exported to ${outputPath}`);
+  } catch (err) {
+    error(`Failed to export: ${err.message}`);
+    process.exit(1);
+  }
+};

package/src/commands/import.js

@@ -0,0 +1,43 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync } from 'node:fs';
+import { resolve, basename } from 'node:path';
+import { addProfile, profileExists, getProfileDir, ensureProfilesDir } from '../profile-store.js';
+import { validateProfile } from '../profile-validator.js';
+import { success, error, warn } from '../output-helpers.js';
+
+export const importCommand = (file, options) => {
+  const filePath = resolve(file);
+  if (!existsSync(filePath)) {
+    error(`File "${file}" does not exist.`);
+    process.exit(1);
+  }
+
+  // Derive name from filename if not provided
+  const name = options.name || basename(file).replace(/\.csp\.tar\.gz$/, '').replace(/\.tar\.gz$/, '');
+
+  if (profileExists(name)) {
+    error(`Profile "${name}" already exists. Use --name to specify a different name.`);
+    process.exit(1);
+  }
+
+  ensureProfilesDir();
+  const profileDir = getProfileDir(name);
+  mkdirSync(profileDir, { recursive: true });
+
+  try {
+    execFileSync('tar', ['-xzf', filePath, '-C', profileDir], { stdio: 'pipe' });
+  } catch (err) {
+    error(`Failed to extract: ${err.message}`);
+    process.exit(1);
+  }
+
+  // Validate imported profile
+  const validation = validateProfile(profileDir);
+  if (!validation.valid) {
+    warn('Imported profile has issues:');
+    validation.errors.forEach((e) => warn(`  ${e}`));
+  }
+
+  addProfile(name, { description: options.description || `Imported from ${basename(file)}` });
+  success(`Profile "${name}" imported from ${filePath}`);
+};

package/src/commands/init.js

@@ -0,0 +1,21 @@
+import { existsSync } from 'node:fs';
+import { ensureProfilesDir, getActive, profileExists } from '../profile-store.js';
+import { createCommand } from './create.js';
+import { success, info, warn } from '../output-helpers.js';
+import { PROFILES_DIR } from '../constants.js';
+
+export const initCommand = () => {
+  if (existsSync(PROFILES_DIR) && getActive()) {
+    const active = getActive();
+    info(`Already initialized. Active profile: "${active}"`);
+    info(`Profiles directory: ${PROFILES_DIR}`);
+    return;
+  }
+
+  ensureProfilesDir();
+  info('Initializing Claude Switch Profile...');
+
+  // Create default profile from current state
+  createCommand('default', { description: 'Default profile (initial capture)' });
+  success('Initialization complete. Your current setup is saved as "default".');
+};

package/src/commands/list.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk';
+import { readProfiles, getActive } from '../profile-store.js';
+import { info } from '../output-helpers.js';
+
+export const listCommand = () => {
+  const profiles = readProfiles();
+  const active = getActive();
+  const names = Object.keys(profiles);
+
+  if (names.length === 0) {
+    info('No profiles found. Run "csp create <name>" to create one.');
+    return;
+  }
+
+  console.log('');
+  for (const name of names) {
+    const meta = profiles[name];
+    const isActive = name === active;
+    const marker = isActive ? chalk.green(' * ') : '   ';
+    const label = isActive ? chalk.green.bold(name) : name;
+    const desc = meta.description ? chalk.dim(` — ${meta.description}`) : '';
+    const date = meta.created ? chalk.dim(` (${meta.created.split('T')[0]})`) : '';
+    console.log(`${marker}${label}${desc}${date}`);
+  }
+  console.log('');
+};

package/src/commands/save.js

@@ -0,0 +1,22 @@
+import { getActive, profileExists, getProfileDir } from '../profile-store.js';
+import { saveSymlinks } from '../symlink-manager.js';
+import { saveFiles } from '../file-operations.js';
+import { success, error } from '../output-helpers.js';
+
+export const saveCommand = () => {
+  const active = getActive();
+  if (!active) {
+    error('No active profile. Run "csp create <name>" first.');
+    process.exit(1);
+  }
+
+  if (!profileExists(active)) {
+    error(`Active profile "${active}" directory is missing.`);
+    process.exit(1);
+  }
+
+  const profileDir = getProfileDir(active);
+  saveSymlinks(profileDir);
+  saveFiles(profileDir);
+  success(`Saved current state to profile "${active}"`);
+};