@aravhawk/cc-switch 2.1.1 → 3.0.0

package/dist/index.js

@@ -6,7 +6,7 @@ import * as clack from "@clack/prompts";
 import { createRequire } from "module";
 
 // src/profiles.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, rm, readdir, rename as fsRename, access } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, rm, readdir, rename as fsRename, access, cp, copyFile, stat as fsStat } from "fs/promises";
 import { dirname as dirname2 } from "path";
 
 // src/paths.ts
@@ -14,15 +14,38 @@ import { homedir } from "os";
 import { join } from "path";
 var CLAUDE_DIR = join(homedir(), ".claude");
 var CLAUDE_SETTINGS = join(CLAUDE_DIR, "settings.json");
+var CLAUDE_MD = join(CLAUDE_DIR, "CLAUDE.md");
+var CLAUDE_AGENTS_DIR = join(CLAUDE_DIR, "agents");
+var CLAUDE_SKILLS_DIR = join(CLAUDE_DIR, "skills");
+var CLAUDE_PLUGINS_DIR = join(CLAUDE_DIR, "plugins");
+var CLAUDE_TEAMS_DIR = join(CLAUDE_DIR, "teams");
 var CC_SWITCH_DIR = join(homedir(), ".cc-switch");
 var PROFILES_DIR = join(CC_SWITCH_DIR, "profiles");
 var STATE_FILE = join(CC_SWITCH_DIR, "state.json");
+var AVAILABLE_MANAGED_PATHS = [
+  { name: "CLAUDE.md", label: "Instructions (CLAUDE.md)", claudePath: CLAUDE_MD },
+  { name: "agents", label: "Agents", claudePath: CLAUDE_AGENTS_DIR },
+  { name: "skills", label: "Skills", claudePath: CLAUDE_SKILLS_DIR },
+  { name: "plugins", label: "Plugins", claudePath: CLAUDE_PLUGINS_DIR },
+  { name: "teams", label: "Teams", claudePath: CLAUDE_TEAMS_DIR }
+];
+var DEFAULT_MANAGED_PATHS = ["CLAUDE.md", "agents", "skills"];
 function getProfileDir(profileName) {
   return join(PROFILES_DIR, profileName);
 }
 function getProfileSettings(profileName) {
   return join(getProfileDir(profileName), "settings.json");
 }
+function getProfileMetaPath(profileName) {
+  return join(getProfileDir(profileName), "profile.json");
+}
+function getProfileManagedPath(profileName, managedName) {
+  const valid = AVAILABLE_MANAGED_PATHS.some((p) => p.name === managedName);
+  if (!valid) {
+    throw new Error(`Invalid managed path name: "${managedName}"`);
+  }
+  return join(getProfileDir(profileName), managedName);
+}
 
 // src/state.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
@@ -129,6 +152,67 @@ for (const template of PROVIDER_TEMPLATES) {
 function getTemplateConfig(name) {
   return PROVIDER_TEMPLATES.find((template) => template.name === name);
 }
+async function getProfileType(profileName) {
+  const meta = await readProfileMeta(profileName);
+  return meta?.type === "full" ? "full" : "settings";
+}
+async function readProfileMeta(profileName) {
+  let data;
+  try {
+    data = await readFile2(getProfileMetaPath(profileName), "utf-8");
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  }
+  try {
+    return JSON.parse(data);
+  } catch {
+    throw new Error(`Profile metadata for "${profileName}" is corrupt (profile.json). Delete and recreate the profile.`);
+  }
+}
+async function writeProfileMeta(profileName, type, managedPaths) {
+  const metaPath = getProfileMetaPath(profileName);
+  const meta = { type, version: 1, managedPaths };
+  const tempFile = `${metaPath}.tmp`;
+  await writeFile2(tempFile, JSON.stringify(meta, null, 2), "utf-8");
+  await fsRename(tempFile, metaPath);
+}
+async function syncManagedPath(source, dest) {
+  let sourceStat;
+  try {
+    sourceStat = await fsStat(source);
+  } catch (e) {
+    if (e.code === "ENOENT") return;
+    throw e;
+  }
+  await rm(dest, { recursive: true, force: true });
+  if (sourceStat.isDirectory()) {
+    await cp(source, dest, { recursive: true, verbatimSymlinks: true });
+  } else {
+    await mkdir2(dirname2(dest), { recursive: true });
+    await copyFile(source, dest);
+  }
+}
+function resolveManagedClaudePath(managedName) {
+  const entry = AVAILABLE_MANAGED_PATHS.find((p) => p.name === managedName);
+  return entry?.claudePath;
+}
+async function mirrorFullProfile(profileName, managedPaths) {
+  for (const name of managedPaths) {
+    const claudePath = resolveManagedClaudePath(name);
+    if (!claudePath) continue;
+    const destPath = getProfileManagedPath(profileName, name);
+    await syncManagedPath(claudePath, destPath);
+  }
+}
+async function loadFullProfile(profileName, managedPaths) {
+  for (const name of managedPaths) {
+    const claudePath = resolveManagedClaudePath(name);
+    if (!claudePath) continue;
+    const sourcePath = getProfileManagedPath(profileName, name);
+    await syncManagedPath(sourcePath, claudePath);
+  }
+}
 function getProviderTemplates() {
   return PROVIDER_TEMPLATES.map((template) => ({
     name: template.name,
@@ -156,10 +240,16 @@ async function listProfiles() {
   try {
     await mkdir2(PROFILES_DIR, { recursive: true });
     const entries = await readdir(PROFILES_DIR, { withFileTypes: true });
-    const profiles = entries.filter((entry) => entry.isDirectory()).map((entry) => ({
-      name: entry.name,
-      isActive: entry.name === state.activeProfile
-    }));
+    const profiles = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const type = await getProfileType(entry.name);
+      profiles.push({
+        name: entry.name,
+        isActive: entry.name === state.activeProfile,
+        type
+      });
+    }
     return profiles.sort((a, b) => {
       if (a.isActive) return -1;
       if (b.isActive) return 1;
@@ -209,13 +299,17 @@ function applyTemplateOverrides(settingsContent, template, apiKey) {
   parsed.env = env;
   return JSON.stringify(parsed, null, 2);
 }
-async function mirrorSettings(profileName) {
+async function mirrorActiveProfile(profileName) {
   const profileSettings = getProfileSettings(profileName);
   await mkdir2(dirname2(profileSettings), { recursive: true });
   const currentSettings = await readFile2(CLAUDE_SETTINGS, "utf-8");
   const tempFile = `${profileSettings}.tmp`;
   await writeFile2(tempFile, currentSettings, "utf-8");
   await fsRename(tempFile, profileSettings);
+  const meta = await readProfileMeta(profileName);
+  if (meta?.type === "full" && meta.managedPaths.length > 0) {
+    await mirrorFullProfile(profileName, meta.managedPaths);
+  }
 }
 async function switchProfile(targetProfile) {
   const validation = validateProfileName(targetProfile);
@@ -228,15 +322,25 @@ async function switchProfile(targetProfile) {
   }
   const state = await readState();
   const activeProfile = state.activeProfile;
-  await mirrorSettings(activeProfile);
   if (targetProfile === activeProfile) {
     throw new Error(`Profile "${targetProfile}" is already active`);
   }
+  await mirrorActiveProfile(activeProfile);
   const targetSettings = getProfileSettings(targetProfile);
   const newSettings = await readFile2(targetSettings, "utf-8");
   const tempFile = `${CLAUDE_SETTINGS}.tmp`;
   await writeFile2(tempFile, newSettings, "utf-8");
   await fsRename(tempFile, CLAUDE_SETTINGS);
+  const activeMeta = await readProfileMeta(activeProfile);
+  const targetMeta = await readProfileMeta(targetProfile);
+  if (targetMeta?.type === "full" && targetMeta.managedPaths.length > 0) {
+    await loadFullProfile(targetProfile, targetMeta.managedPaths);
+  } else if (activeMeta?.type === "full" && activeMeta.managedPaths.length > 0) {
+    for (const name of activeMeta.managedPaths) {
+      const claudePath = resolveManagedClaudePath(name);
+      if (claudePath) await rm(claudePath, { recursive: true, force: true });
+    }
+  }
   await updateState({ activeProfile: targetProfile });
 }
 async function createProfile(profileName, options) {
@@ -269,7 +373,7 @@ async function createProfile(profileName, options) {
   }
   let settingsToWrite = currentSettings;
   if (templateConfig) {
-    await mirrorSettings(activeProfileForTemplate ?? "default");
+    await mirrorActiveProfile(activeProfileForTemplate ?? "default");
     settingsToWrite = applyTemplateOverrides(currentSettings, templateConfig, apiKey);
   }
   const tempFile = `${profileSettings}.tmp`;
@@ -280,6 +384,11 @@ async function createProfile(profileName, options) {
     await writeFile2(tempCurrentSettings, settingsToWrite, "utf-8");
     await fsRename(tempCurrentSettings, CLAUDE_SETTINGS);
   }
+  if (options?.full) {
+    const managedPaths = options.managedPaths ?? [];
+    await writeProfileMeta(profileName, "full", managedPaths);
+    await mirrorFullProfile(profileName, managedPaths);
+  }
   await updateState({ activeProfile: profileName });
 }
 async function deleteProfile(profileName) {
@@ -322,6 +431,7 @@ async function renameProfile(oldName, newName) {
 }
 
 // src/index.ts
+var VALID_MANAGED_PATH_NAMES = AVAILABLE_MANAGED_PATHS.map((p) => p.name);
 var require2 = createRequire(import.meta.url);
 function getCliVersion() {
   try {
@@ -399,12 +509,15 @@ async function showProfileList(profiles) {
   }
   console.log("\nProfiles:");
   for (const profile of resolvedProfiles) {
-    const marker = profile.isActive ? " (active)" : "";
-    console.log(`  ${profile.name}${marker}`);
+    const markers = [];
+    if (profile.isActive) markers.push("active");
+    if (profile.type === "full") markers.push("full");
+    const suffix = markers.length > 0 ? ` (${markers.join(", ")})` : "";
+    console.log(`  ${profile.name}${suffix}`);
   }
   console.log();
 }
-program.name("cc-switch").description("Profile manager for Claude Code settings").version(cliVersion, "-V, --version", "output the version number").argument("[profile]", "Profile name to switch to").option("--switch <name>", "Switch to a different profile").option("--create <name>", "Create a new profile from current settings").option("--delete <name>", "Delete a profile").option("--rename <names...>", "Rename a profile").option("--to <name>", "New name for rename").option("--current", "Show the current active profile").option("--list", "List all profiles").option("--template <provider>", "Create profile using a provider template").option("--api-key <key>", "API key for the provider template");
+program.name("cc-switch").description("Profile manager for Claude Code settings").version(cliVersion, "-V, --version", "output the version number").argument("[profile]", "Profile name to switch to").option("--switch <name>", "Switch to a different profile").option("--create <name>", "Create a new profile from current settings").option("--delete <name>", "Delete a profile").option("--rename <names...>", "Rename a profile").option("--to <name>", "New name for rename").option("--current", "Show the current active profile").option("--list", "List all profiles").option("--template <provider>", "Create profile using a provider template").option("--api-key <key>", "API key for the provider template").option("--full", "Create a full profile (settings, instructions, agents, skills)").option("--include <paths>", "Comma-separated paths to include in full profile (default: CLAUDE.md,agents,skills)");
 async function interactiveMode() {
   clack.intro("cc-switch - Claude Code Profile Manager");
   try {
@@ -430,10 +543,13 @@ async function interactiveMode() {
     }
     switch (action) {
       case "switch": {
-        const profileChoices = profiles.map((p) => ({
-          value: p.name,
-          label: p.isActive ? `${p.name} (active)` : p.name
-        }));
+        const profileChoices = profiles.map((p) => {
+          const markers = [];
+          if (p.isActive) markers.push("active");
+          if (p.type === "full") markers.push("full");
+          const suffix = markers.length > 0 ? ` (${markers.join(", ")})` : "";
+          return { value: p.name, label: `${p.name}${suffix}` };
+        });
         const selectedProfile = await clack.select({
           message: "Select profile to switch to:",
           options: profileChoices
@@ -462,10 +578,43 @@ async function interactiveMode() {
           clack.cancel("Operation cancelled");
           process.exit(0);
         }
+        const profileType = await clack.select({
+          message: "Profile type:",
+          options: [
+            { value: "settings", label: "Settings only (swap settings.json)" },
+            { value: "full", label: "Full (swap settings, instructions, agents, skills)" }
+          ]
+        });
+        if (clack.isCancel(profileType)) {
+          clack.cancel("Operation cancelled");
+          process.exit(0);
+        }
+        const isFull = profileType === "full";
+        let selectedManagedPaths = [];
+        if (isFull) {
+          const pathSelection = await clack.multiselect({
+            message: "Which paths to include in this profile?",
+            options: AVAILABLE_MANAGED_PATHS.map((p) => ({
+              value: p.name,
+              label: p.label
+            })),
+            initialValues: [...DEFAULT_MANAGED_PATHS]
+          });
+          if (clack.isCancel(pathSelection)) {
+            clack.cancel("Operation cancelled");
+            process.exit(0);
+          }
+          selectedManagedPaths = pathSelection;
+        }
         const templateSelection = await promptForTemplateSelection();
-        await createProfile(profileName, templateSelection);
+        await createProfile(profileName, {
+          ...templateSelection,
+          full: isFull,
+          managedPaths: isFull ? selectedManagedPaths : void 0
+        });
         const templateSuffix = templateSelection.template ? ` with template "${templateSelection.template}"` : "";
-        clack.outro(`Created profile "${profileName}"${templateSuffix}`);
+        const fullSuffix = isFull ? " (full profile)" : "";
+        clack.outro(`Created profile "${profileName}"${templateSuffix}${fullSuffix}`);
         break;
       }
       case "delete": {
@@ -589,6 +738,33 @@ async function runCli() {
     console.error(`Error: API key is required for template "${templateMeta.label}".`);
     process.exit(1);
   }
+  if (opts.full && !opts.create) {
+    console.error("Error: --full can only be used with --create.");
+    process.exit(1);
+  }
+  if (opts.include && !opts.full) {
+    console.error("Error: --include can only be used with --full.");
+    process.exit(1);
+  }
+  let parsedManagedPaths;
+  if (opts.full) {
+    if (opts.include) {
+      parsedManagedPaths = opts.include.split(",").map((s) => s.trim()).filter(Boolean);
+      if (parsedManagedPaths.length === 0) {
+        console.error("Error: --include must specify at least one valid path.");
+        console.error(`Valid paths: ${VALID_MANAGED_PATH_NAMES.join(", ")}`);
+        process.exit(1);
+      }
+      const invalid = parsedManagedPaths.filter((p) => !VALID_MANAGED_PATH_NAMES.includes(p));
+      if (invalid.length > 0) {
+        console.error(`Error: Invalid managed path(s): ${invalid.join(", ")}`);
+        console.error(`Valid paths: ${VALID_MANAGED_PATH_NAMES.join(", ")}`);
+        process.exit(1);
+      }
+    } else {
+      parsedManagedPaths = [...DEFAULT_MANAGED_PATHS];
+    }
+  }
   if (actionFlags.length > 1) {
     console.error("Error: Please provide only one action flag at a time.");
     process.exit(1);
@@ -631,10 +807,13 @@ async function runCli() {
         }
         await createProfile(opts.create, {
           template: resolvedTemplate,
-          apiKey: opts.apiKey
+          apiKey: opts.apiKey,
+          full: opts.full,
+          managedPaths: parsedManagedPaths
         });
         const templateSuffix = resolvedTemplate ? ` with template "${resolvedTemplate}"` : "";
-        console.log(`Created profile "${opts.create}"${templateSuffix}`);
+        const fullSuffix = opts.full ? " (full profile)" : "";
+        console.log(`Created profile "${opts.create}"${templateSuffix}${fullSuffix}`);
         process.exit(0);
         break;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aravhawk/cc-switch",
-  "version": "2.1.1",
+  "version": "3.0.0",
   "description": "Profile manager for Claude Code settings",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
   "author": "Arav",
   "license": "MIT",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.7.0"
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",