claude-switch-profile 1.0.2 → 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog
+
+All notable changes to `claude-switch-profile` are documented here.
+
+## [1.1.0] - 2026-03-13
+
+### Added
+- ✨ **`csp uninstall` command** — Cleanly remove CSP and restore a chosen profile to `~/.claude` before wiping all profile data. Supports `--force` and `--profile <name>` flags.
+
+### Changed
+- 🔄 **`saveSymlinks` now handles real dirs/files** — When a managed item in `~/.claude` is a real directory or file (not yet a symlink), `saveSymlinks` moves it into the profile directory and replaces it with a symlink in-place. Fixes the case where switching from a fresh `~/.claude` setup left the default profile empty.
+- 🔄 **`removeSymlinks` now removes real dirs/files** — Previously only removed symlinks; now also removes real directories and files for managed items so `createSymlinks` is never blocked.
+- 🔄 **`createSymlinks` uses `rmSync` instead of `unlinkSync`** — Correctly handles pre-existing directories (not just files/symlinks) when restoring a profile.
+
+### Fixed
+- 🐛 **`statusline.cjs` broken after switch to default profile** — `saveSymlinks` was copying the file into the profile directory, causing `require('./lib/...')` to fail because `lib/` does not exist there. Now the file stays as a symlink pointing to the source project.
+
+---
+
+## [1.0.2] - 2026-03-12
+
+### Fixed
+- 🐛 **`csp create` produces clean profiles** — New profiles no longer inherit the current session state; they start empty and isolated.
+
+### Changed
+- 🔄 **Max backups reduced to 2** — Keeps `.backup/` lean.
+
+---
+
+## [1.0.1] - 2026-03-11
+
+### Fixed
+- 🐛 Initial bug fixes after first release.
+
+---
+
+## [1.0.0] - 2026-03-11
+
+### Added
+- ✨ Initial release of `claude-switch-profile`
+- `csp init`, `csp create`, `csp use`, `csp save`, `csp list`, `csp current`
+- `csp delete`, `csp export`, `csp import`, `csp diff`
+- Symlink + copy strategy for isolating Claude Code profiles
+- Lock file, automatic backups, Claude process detection
+- Environment variable overrides (`CSP_HOME`, `CSP_CLAUDE_DIR`, `CSP_PROFILES_DIR`)

package/README.md

@@ -1,5 +1,9 @@
 # Claude Switch Profile (CSP)
 
+[![npm version](https://img.shields.io/npm/v/claude-switch-profile)](https://www.npmjs.com/package/claude-switch-profile)
+[![Node.js >= 18](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen)](https://nodejs.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
 A CLI tool for managing multiple Claude Code configurations and profiles. Effortlessly switch between different development setups, each with their own rules, agents, skills, and settings.
 
 ## Overview
@@ -104,13 +108,22 @@ csp list
 Output example:
 
 ```
- * default — Default profile (initial capture) (2026-03-11)
+ * default — Vanilla Claude defaults (2026-03-11)
    work — Work setup (2026-03-11)
    experimental (2026-03-11)
 ```
 
 The `*` marks the active profile.
 
+### 6. Uninstall CSP
+
+Remove CSP and restore your Claude Code to its original state:
+
+```bash
+csp uninstall
+# Uninstall CSP and remove all profiles? This cannot be undone. (y/N)
+```
+
 ## Commands Reference
 
 ### init
@@ -403,6 +416,44 @@ File differences:
 - Lists file presence and content differences
 - Shows which files differ and in which profile they exist
 
+### uninstall
+
+Remove all profiles and restore Claude Code to its pre-CSP state.
+
+```bash
+csp uninstall
+```
+
+**Options:**
+- `-f, --force` — Skip confirmation prompt
+- `--profile <name>` — Restore a specific profile instead of the active one
+
+**Examples:**
+
+Uninstall with confirmation:
+```bash
+csp uninstall
+# Uninstall CSP and remove all profiles? This cannot be undone. (y/N)
+```
+
+Restore a specific profile during uninstall:
+```bash
+csp uninstall --profile production
+```
+
+Force uninstall without prompt:
+```bash
+csp uninstall --force
+```
+
+**Behavior:**
+1. Creates a final backup at `~/.claude-profiles/.backup/`
+2. Restores the active profile (or `--profile` choice) to `~/.claude`
+3. Removes `~/.claude-profiles/` entirely
+4. Prints reminder to run `npm uninstall -g claude-switch-profile`
+
+---
+
 ## How Profiles Work
 
 ### Profile Storage
@@ -470,6 +521,16 @@ Profiles are stored in `~/.claude-profiles/`:
 - Each profile needs its own independent configuration
 - Prevents accidental modifications from affecting other profiles
 
+### Real Directory Handling
+
+When `csp save` (or `csp use`) encounters a **real directory/file** in `~/.claude` for a managed item (instead of a symlink), it automatically:
+
+1. **Moves** the real item into the profile directory (`~/.claude-profiles/<name>/<item>`)
+2. **Replaces** it with a symlink at the original location
+3. **Records** the new location in `source.json`
+
+This ensures that profiles created from a fresh `~/.claude` setup (before any symlinks exist) work correctly on first use.
+
 ## Safety Features
 
 ### Lock File
@@ -699,6 +760,10 @@ npm run test:cli        # CLI integration tests
 npm run test:safety     # Safety feature tests
 ```
 
+### Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for version history and migration guidance.
+
 ### Project Structure
 
 ```

package/bin/csp.js

@@ -15,6 +15,7 @@ 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';
+import { uninstallCommand } from '../src/commands/uninstall.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
@@ -88,4 +89,11 @@ program
   .description('Compare two profiles (use "current" for active profile)')
   .action(diffCommand);
 
+program
+  .command('uninstall')
+  .description('Remove all profiles and restore Claude Code to pre-CSP state')
+  .option('-f, --force', 'Skip confirmation prompt')
+  .option('--profile <name>', 'Restore specific profile instead of active one')
+  .action(uninstallCommand);
+
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-switch-profile",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "CLI tool for managing multiple Claude Code profiles",
   "type": "module",
   "bin": {

package/src/commands/create.js

@@ -1,8 +1,8 @@
-import { mkdirSync, cpSync, existsSync, writeFileSync, readdirSync } from 'node:fs';
+import { mkdirSync, cpSync, existsSync, statSync, writeFileSync, readFileSync, copyFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { addProfile, getActive, setActive, profileExists, getProfileDir } from '../profile-store.js';
 import { saveFiles } from '../file-operations.js';
-import { SYMLINK_ITEMS, SYMLINK_DIRS, SOURCE_FILE } from '../constants.js';
+import { CLAUDE_DIR, SYMLINK_ITEMS, SYMLINK_DIRS, SOURCE_FILE } from '../constants.js';
 import { success, error, info, warn } from '../output-helpers.js';
 
 export const createCommand = (name, options) => {
@@ -45,6 +45,22 @@ export const createCommand = (name, options) => {
       warn(`No recognized items found in "${sourcePath}". Expected: ${SYMLINK_ITEMS.join(', ')}`);
     }
 
+    // Inherit missing items from current state (hooks, statusline, etc.)
+    for (const item of SYMLINK_ITEMS) {
+      if (sourceMap[item]) continue;
+      const src = join(CLAUDE_DIR, item);
+      if (!existsSync(src)) continue;
+      try {
+        const dest = join(profileDir, item);
+        if (statSync(src).isDirectory()) {
+          cpSync(src, dest, { recursive: true, dereference: true });
+        } else {
+          copyFileSync(src, dest);
+        }
+        sourceMap[item] = dest;
+      } catch { /* skip */ }
+    }
+
     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'}`);
@@ -52,21 +68,48 @@ export const createCommand = (name, options) => {
     // Also copy current mutable files
     saveFiles(profileDir);
   } else {
-    // Create brand new independent profile — everything fresh, nothing copied
+    // Create new independent profile — inherit infrastructure from current state
     mkdirSync(profileDir, { recursive: true });
 
-    // Create self-contained directories for each symlink directory item
+    // Copy all current symlink items (dirs + files) into profile — dereference symlinks
     const sourceMap = {};
+    for (const item of SYMLINK_ITEMS) {
+      const src = join(CLAUDE_DIR, item);
+      const dest = join(profileDir, item);
+      try {
+        if (!existsSync(src)) continue;
+        if (statSync(src).isDirectory()) {
+          cpSync(src, dest, { recursive: true, dereference: true });
+        } else {
+          copyFileSync(src, dest);
+        }
+        sourceMap[item] = dest;
+      } catch { /* skip unreadable items */ }
+    }
+
+    // Fallback: ensure empty dirs for any missing SYMLINK_DIRS
     for (const item of SYMLINK_DIRS) {
-      const itemDir = join(profileDir, item);
-      mkdirSync(itemDir, { recursive: true });
-      sourceMap[item] = itemDir;
+      if (!sourceMap[item]) {
+        const itemDir = join(profileDir, item);
+        mkdirSync(itemDir, { recursive: true });
+        sourceMap[item] = itemDir;
+      }
     }
 
     writeFileSync(join(profileDir, SOURCE_FILE), JSON.stringify(sourceMap, null, 2) + '\n');
-    // Do NOT call saveFiles() — new profile should start clean
-    // without inheriting settings.json, .env, .ck*, etc. from current state
-    info('Created new independent profile (clean state)');
+
+    // Copy hooks config from settings.json (hooks won't run without it)
+    const settingsPath = join(CLAUDE_DIR, 'settings.json');
+    if (existsSync(settingsPath)) {
+      try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        if (settings.hooks) {
+          writeFileSync(join(profileDir, 'settings.json'), JSON.stringify({ hooks: settings.hooks }, null, 2) + '\n');
+        }
+      } catch { /* parse error — skip */ }
+    }
+
+    info('Created new independent profile (infrastructure inherited)');
   }
 
   addProfile(name, { description: options.description || '' });

package/src/commands/init.js

@@ -1,8 +1,8 @@
-import { existsSync } from 'node:fs';
-import { ensureProfilesDir, getActive, profileExists } from '../profile-store.js';
-import { createCommand } from './create.js';
+import { existsSync, mkdirSync, writeFileSync, lstatSync } from 'node:fs';
+import { join } from 'node:path';
+import { ensureProfilesDir, getActive, addProfile, setActive, getProfileDir } from '../profile-store.js';
 import { success, info, warn } from '../output-helpers.js';
-import { PROFILES_DIR } from '../constants.js';
+import { PROFILES_DIR, SOURCE_FILE, CLAUDE_DIR, SYMLINK_ITEMS } from '../constants.js';
 
 export const initCommand = () => {
   if (existsSync(PROFILES_DIR) && getActive()) {
@@ -15,7 +15,30 @@ export const initCommand = () => {
   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".');
+  // Create "default" as vanilla Claude — empty profile with no symlinks or copy files.
+  // Switching to this profile removes all managed items, restoring Claude's built-in defaults.
+  const profileDir = getProfileDir('default');
+  mkdirSync(profileDir, { recursive: true });
+  writeFileSync(join(profileDir, SOURCE_FILE), '{}\n');
+
+  addProfile('default', { description: 'Vanilla Claude defaults' });
+  setActive('default');
+
+  success('Initialization complete. "default" profile uses vanilla Claude defaults.');
+
+  // Warn if real directories exist that should be captured into a profile
+  const realItems = SYMLINK_ITEMS.filter((item) => {
+    const itemPath = join(CLAUDE_DIR, item);
+    try {
+      const stat = lstatSync(itemPath);
+      return !stat.isSymbolicLink() && (stat.isDirectory() || stat.isFile());
+    } catch {
+      return false;
+    }
+  });
+
+  if (realItems.length) {
+    warn(`Real directories/files detected: ${realItems.join(', ')}`);
+    info('Run "csp create <name>" to capture them into a profile.');
+  }
 };

package/src/commands/uninstall.js

@@ -0,0 +1,89 @@
+import { existsSync, rmSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { getActive, profileExists, getProfileDir } from '../profile-store.js';
+import { removeSymlinks, restoreSymlinks } from '../symlink-manager.js';
+import { removeFiles, restoreFiles } from '../file-operations.js';
+import { withLock, createBackup, warnIfClaudeRunning } from '../safety.js';
+import { PROFILES_DIR } from '../constants.js';
+import { success, error, info, 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 uninstallCommand = async (options) => {
+  const active = getActive();
+
+  if (!existsSync(PROFILES_DIR)) {
+    info('No profiles directory found. CSP is not initialized.');
+    info('To remove the CLI: npm uninstall -g claude-switch-profile');
+    return;
+  }
+
+  // Show what will happen
+  console.log('');
+  info('This will:');
+  if (options.profile && profileExists(options.profile)) {
+    info(`  1. Restore profile "${options.profile}" to ~/.claude`);
+  } else if (active && profileExists(active)) {
+    info(`  1. Restore active profile "${active}" to ~/.claude (use --profile <name> to choose)`);
+  } else {
+    warn('  1. No profile to restore (managed items will be removed)');
+  }
+  info(`  2. Remove all profiles: ${PROFILES_DIR}`);
+  info('  3. You can then run: npm uninstall -g claude-switch-profile');
+  console.log('');
+
+  if (!options.force) {
+    const confirmed = await confirm('Uninstall CSP and remove all profiles? This cannot be undone. (y/N) ');
+    if (!confirmed) {
+      warn('Cancelled.');
+      return;
+    }
+  }
+
+  warnIfClaudeRunning();
+
+  await withLock(async () => {
+    // 1. Create final backup before uninstall
+    try {
+      const backupPath = createBackup();
+      info(`Final backup created at ${backupPath}`);
+    } catch {
+      // Non-critical — profiles dir may be empty
+    }
+
+    // 2. Determine which profile to restore
+    const restoreProfile = options.profile || active;
+
+    // 3. Remove current managed items from ~/.claude
+    removeSymlinks();
+    removeFiles();
+
+    // 4. Restore the chosen profile's config
+    if (restoreProfile && profileExists(restoreProfile)) {
+      const profileDir = getProfileDir(restoreProfile);
+      restoreSymlinks(profileDir);
+      restoreFiles(profileDir);
+      success(`Restored "${restoreProfile}" profile to ~/.claude`);
+    } else {
+      warn('No profile restored. ~/.claude managed items have been cleared.');
+    }
+  });
+
+  // 5. Remove profiles directory (after lock is released)
+  rmSync(PROFILES_DIR, { recursive: true, force: true });
+  success('Removed all profiles and CSP data.');
+
+  console.log('');
+  info('To complete uninstall, run:');
+  info('  npm uninstall -g claude-switch-profile');
+  info('');
+  info('Restart your Claude Code session to apply changes.');
+};

package/src/symlink-manager.js

@@ -1,4 +1,4 @@
-import { existsSync, readlinkSync, symlinkSync, unlinkSync, lstatSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readlinkSync, symlinkSync, unlinkSync, lstatSync, readFileSync, writeFileSync, cpSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { CLAUDE_DIR, SYMLINK_ITEMS, SOURCE_FILE } from './constants.js';
 
@@ -18,16 +18,24 @@ export const readCurrentSymlinks = () => {
   return sourceMap;
 };
 
-// Remove all managed symlinks from ~/.claude
+// Remove all managed symlinks (and real dirs/files) from ~/.claude
 export const removeSymlinks = () => {
   for (const item of SYMLINK_ITEMS) {
     const itemPath = join(CLAUDE_DIR, item);
     try {
-      if (existsSync(itemPath) && lstatSync(itemPath).isSymbolicLink()) {
+      if (!existsSync(itemPath) && !lstatSync(itemPath).isSymbolicLink()) continue;
+    } catch {
+      continue; // Doesn't exist at all
+    }
+    try {
+      const stat = lstatSync(itemPath);
+      if (stat.isSymbolicLink()) {
         unlinkSync(itemPath);
+      } else if (stat.isDirectory() || stat.isFile()) {
+        rmSync(itemPath, { recursive: true });
       }
     } catch {
-      // Already gone or not a symlink — skip
+      // Already gone — skip
     }
   }
 };
@@ -38,9 +46,9 @@ export const createSymlinks = (sourceMap) => {
     if (!SYMLINK_ITEMS.includes(item)) continue;
     const itemPath = join(CLAUDE_DIR, item);
 
-    // Remove existing if present
+    // Remove existing (symlink, file, or directory)
     try {
-      if (lstatSync(itemPath)) unlinkSync(itemPath);
+      if (lstatSync(itemPath)) rmSync(itemPath, { recursive: true, force: true });
     } catch {
       // Doesn't exist — fine
     }
@@ -53,8 +61,33 @@ export const createSymlinks = (sourceMap) => {
 };
 
 // Save current symlink targets to profileDir/source.json
+// For real dirs/files: move them into profileDir and create symlinks in their place
 export const saveSymlinks = (profileDir) => {
-  const sourceMap = readCurrentSymlinks();
+  const sourceMap = {};
+  for (const item of SYMLINK_ITEMS) {
+    const itemPath = join(CLAUDE_DIR, item);
+    try {
+      if (!existsSync(itemPath) && !lstatSync(itemPath).isSymbolicLink()) continue;
+    } catch {
+      continue;
+    }
+    try {
+      const stat = lstatSync(itemPath);
+      if (stat.isSymbolicLink()) {
+        // Already a symlink — just record its target
+        sourceMap[item] = resolve(CLAUDE_DIR, readlinkSync(itemPath));
+      } else if (stat.isDirectory() || stat.isFile()) {
+        // Real dir/file — move into profileDir, replace with symlink
+        const dest = join(profileDir, item);
+        cpSync(itemPath, dest, { recursive: true });
+        rmSync(itemPath, { recursive: true });
+        symlinkSync(dest, itemPath);
+        sourceMap[item] = dest;
+      }
+    } catch {
+      // Not readable — skip
+    }
+  }
   writeFileSync(join(profileDir, SOURCE_FILE), JSON.stringify(sourceMap, null, 2) + '\n');
   return sourceMap;
 };