contextswitch 0.1.1

package/dist/cli.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+import {
+  configManager
+} from "./chunk-XGE4JP55.js";
+import {
+  paths
+} from "./chunk-A7YXSI66.js";
+import "./chunk-PNKVD2UK.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import picocolors from "picocolors";
+import { existsSync, readFileSync, unlinkSync } from "fs";
+import { join } from "path";
+var pc = picocolors;
+function getVersion() {
+  try {
+    const packagePath = join(__dirname, "..", "package.json");
+    const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
+    return packageJson.version;
+  } catch {
+    return "0.1.0";
+  }
+}
+function processSessionFallbackMarker() {
+  const markerPath = join(paths.baseDir, "session-fallback.json");
+  if (!existsSync(markerPath)) {
+    return;
+  }
+  try {
+    const content = readFileSync(markerPath, "utf-8");
+    const marker = JSON.parse(content);
+    if (marker.domain && marker.sessionId) {
+      const state = configManager.loadState();
+      if (state.sessions?.[marker.domain]) {
+        state.sessions[marker.domain].sessionId = marker.sessionId;
+        state.sessions[marker.domain].started = (/* @__PURE__ */ new Date()).toISOString();
+        state.sessions[marker.domain].lastActive = (/* @__PURE__ */ new Date()).toISOString();
+        state.activeSession = marker.sessionId;
+        configManager.saveState(state);
+        console.log(pc.yellow(`Note: Previous session for '${marker.domain}' could not be resumed.`));
+        console.log(pc.yellow(`A new session (${marker.sessionId.substring(0, 8)}...) was started automatically.
+`));
+      }
+    }
+    unlinkSync(markerPath);
+  } catch {
+    try {
+      unlinkSync(markerPath);
+    } catch {
+    }
+  }
+}
+var program = new Command();
+program.name("cs").description("Domain-based context management for Claude Code CLI - Each domain represents a project with its own working directory and configuration").version(getVersion()).hook("preAction", () => {
+  paths.ensureDirectories();
+  processSessionFallbackMarker();
+});
+program.command("init").description("Initialize ContextSwitch in the current directory").action(async () => {
+  try {
+    console.log(pc.cyan("\u{1F680} Initializing ContextSwitch..."));
+    paths.ensureDirectories();
+    if (!configManager.domainExists("default")) {
+      console.log(pc.gray("Creating default domain..."));
+      configManager.createDomain("default", {
+        workingDirectory: process.cwd()
+      });
+    }
+    configManager.loadGlobalConfig();
+    console.log(pc.gray(`Configuration directory: ${paths.baseDir}`));
+    console.log(pc.green("\u2705 ContextSwitch initialized successfully!"));
+    console.log(pc.gray("\nNext steps:"));
+    console.log(pc.gray("  \u2022 Create a new domain: cs domain add <name> --working-dir <path>"));
+    console.log(pc.gray("    Example: cs domain add backend --working-dir ~/projects/api"));
+    console.log(pc.gray("  \u2022 Switch to a domain: cs switch <domain>"));
+    console.log(pc.gray("  \u2022 List domains: cs list"));
+  } catch (error) {
+    console.error(pc.red(`\u274C Initialization failed: ${error}`));
+    process.exit(1);
+  }
+});
+program.command("list").alias("ls").description("List all available domains").action(async () => {
+  try {
+    const domains = configManager.listDomains();
+    const state = configManager.loadState();
+    if (domains.length === 0) {
+      console.log(pc.yellow('No domains found. Run "cs init" to get started.'));
+      return;
+    }
+    console.log(pc.cyan("\u{1F4CB} Available domains:\n"));
+    for (const domainName of domains) {
+      const isActive = state.activeDomain === domainName;
+      const domain = configManager.loadDomain(domainName);
+      if (isActive) {
+        console.log(pc.green(`\u25CF ${domainName} (active)`));
+      } else {
+        console.log(`  ${domainName}`);
+      }
+      if (domain.metadata?.description) {
+        console.log(pc.gray(`    ${domain.metadata.description}`));
+      }
+    }
+    console.log(pc.gray(`
+Total: ${domains.length} domain(s)`));
+  } catch (error) {
+    console.error(pc.red(`\u274C Failed to list domains: ${error}`));
+    process.exit(1);
+  }
+});
+program.command("status").description("Show current domain and session status").argument("[domain]", "Domain to check status for (default: current)").action(async (domain) => {
+  try {
+    const state = configManager.loadState();
+    if (!domain) {
+      domain = state.activeDomain || void 0;
+    }
+    if (!domain) {
+      console.log(pc.yellow('No active domain. Use "cs switch <domain>" to activate one.'));
+      return;
+    }
+    const domainConfig = configManager.loadDomain(domain);
+    const session = state.sessions?.[domain];
+    console.log(pc.cyan(`\u{1F4CA} Domain Status: ${domain}
+`));
+    console.log(`Working Directory: ${domainConfig.workingDirectory}`);
+    if (domainConfig.mcpServers && Object.keys(domainConfig.mcpServers).length > 0) {
+      console.log(`MCP Servers: ${Object.keys(domainConfig.mcpServers).join(", ")}`);
+    }
+    if (session) {
+      console.log(`
+${pc.cyan("Session Information:")}`);
+      const { SessionManager } = await import("./session-YAMF4YD7.js");
+      console.log(SessionManager.formatSessionInfo(session));
+    } else {
+      console.log(pc.gray("\nNo active session for this domain."));
+    }
+  } catch (error) {
+    console.error(pc.red(`\u274C Failed to get status: ${error}`));
+    process.exit(1);
+  }
+});
+program.command("switch <domain>").description("Switch to a different domain").option("-f, --force", "Force new session even if one exists").action(async (domain, options) => {
+  const { switchCommand } = await import("./switch-MWKYEYHE.js");
+  await switchCommand(domain, options);
+});
+program.command("reset <domain>").description("Reset a domain session (archives current session)").option("--skip-archive", "Skip archiving the current session").action(async (domain, options) => {
+  const { resetCommand } = await import("./reset-3DSXZKRH.js");
+  await resetCommand(domain, options);
+});
+program.command("archive <domain>").description("Archive the current session for a domain").action(async (domain) => {
+  const { archiveCommand } = await import("./archive-3IGWZBSO.js");
+  await archiveCommand(domain);
+});
+var domainCmd = program.command("domain").description("Manage domains");
+domainCmd.command("add <name>").description('Create a new domain\n\nExamples:\n  cs domain add myapi --working-dir ~/projects/api\n  cs domain add frontend -w /home/user/app -d "React frontend"').option("-w, --working-dir <path>", "Working directory for this domain (defaults to current directory)").option("-d, --description <text>", "Domain description").option("--extends <parent>", "Inherit from parent domain").action(async (name, options) => {
+  try {
+    if (configManager.domainExists(name)) {
+      console.error(pc.red(`\u274C Domain '${name}' already exists`));
+      process.exit(1);
+    }
+    const workingDir = options.workingDir || process.cwd();
+    console.log(pc.cyan(`\u{1F3AF} Creating domain '${name}'...`));
+    configManager.createDomain(name, {
+      workingDirectory: workingDir,
+      extends: options.extends,
+      metadata: {
+        description: options.description,
+        created: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+    console.log(pc.green(`\u2705 Domain '${name}' created successfully!`));
+    console.log(pc.gray(`
+Working directory: ${workingDir}`));
+    console.log(pc.gray(`Configuration file: ${paths.domainConfigFile(name)}`));
+    console.log(pc.gray(`
+Next steps:`));
+    console.log(pc.gray(`  \u2022 Switch to domain: cs switch ${name}`));
+    console.log(pc.gray(`  \u2022 Edit configuration (optional): ${paths.domainConfigFile(name)}`));
+  } catch (error) {
+    console.error(pc.red(`\u274C Failed to create domain: ${error}`));
+    process.exit(1);
+  }
+});
+domainCmd.command("remove <name>").alias("rm").description("Remove a domain from ContextSwitch (does not affect working directory)").action(async (name) => {
+  try {
+    if (!configManager.domainExists(name)) {
+      console.error(pc.red(`\u274C Domain '${name}' not found`));
+      process.exit(1);
+    }
+    const state = configManager.loadState();
+    if (state.activeDomain === name) {
+      console.error(pc.red(`\u274C Cannot remove active domain '${name}'`));
+      console.log(pc.gray("Switch to a different domain first."));
+      process.exit(1);
+    }
+    if (state.sessions?.[name]) {
+      delete state.sessions[name];
+      configManager.saveState(state);
+    }
+    configManager.deleteDomain(name);
+    console.log(pc.green(`\u2705 Domain '${name}' removed successfully`));
+    console.log(pc.gray("The working directory was not modified."));
+    console.log(pc.gray(`You can recreate this domain later with: cs domain add ${name}`));
+  } catch (error) {
+    console.error(pc.red(`\u274C Failed to remove domain: ${error}`));
+    process.exit(1);
+  }
+});
+program.command("doctor").description("Check system configuration and diagnose issues").action(async () => {
+  const { processManager } = await import("./process-WBBCEFGG.js");
+  console.log(pc.cyan("\u{1FA7A} Running diagnostics...\n"));
+  const claudeInstalled = processManager.verifyClaudeInstalled();
+  if (claudeInstalled) {
+    console.log(pc.green("\u2713 Claude CLI is installed"));
+  } else {
+    console.log(pc.red("\u2717 Claude Code CLI not found\n"));
+    console.log(pc.cyan("  Install via npm (recommended):"));
+    console.log(pc.gray("    npm install -g @anthropic-ai/claude-code\n"));
+    console.log(pc.cyan("  Or see the official docs:"));
+    console.log(pc.gray("    https://docs.anthropic.com/en/docs/claude-code\n"));
+  }
+  console.log(pc.green(`\u2713 Config directory: ${paths.baseDir}`));
+  const domains = configManager.listDomains();
+  console.log(pc.green(`\u2713 Domains configured: ${domains.length}`));
+  const processes = processManager.findClaudeProcesses();
+  console.log(pc.green(`\u2713 Claude processes running: ${processes.length}`));
+  console.log(pc.green(`\u2713 Platform: ${paths.platform}`));
+  console.log(pc.cyan("\n\u2728 All checks passed!"));
+});
+program.exitOverride((err) => {
+  if (err.code === "commander.helpDisplayed") {
+    process.exit(0);
+  }
+  if (err.code === "commander.version") {
+    process.exit(0);
+  }
+  console.error(pc.red(`Error: ${err.message}`));
+  process.exit(1);
+});
+program.parse();

package/dist/process-WBBCEFGG.js

@@ -0,0 +1,10 @@
+import {
+  ProcessManager,
+  processManager
+} from "./chunk-56TY2J6E.js";
+import "./chunk-A7YXSI66.js";
+import "./chunk-PNKVD2UK.js";
+export {
+  ProcessManager,
+  processManager
+};

package/dist/reset-3DSXZKRH.js

@@ -0,0 +1,60 @@
+import {
+  archiveCommand
+} from "./chunk-2LUEUGBV.js";
+import {
+  configManager
+} from "./chunk-XGE4JP55.js";
+import {
+  SessionManager,
+  init_session
+} from "./chunk-UKMZ4CUZ.js";
+import "./chunk-A7YXSI66.js";
+import "./chunk-PNKVD2UK.js";
+
+// src/commands/reset.ts
+import picocolors from "picocolors";
+init_session();
+var pc = picocolors;
+async function resetCommand(domainName, options = {}) {
+  try {
+    if (!configManager.domainExists(domainName)) {
+      throw new Error(`Domain '${domainName}' not found`);
+    }
+    const state = configManager.loadState();
+    const session = state.sessions?.[domainName];
+    if (!session) {
+      console.log(pc.yellow(`Domain '${domainName}' has no active session to reset.`));
+      return;
+    }
+    console.log(pc.cyan(`\u{1F504} Resetting domain '${domainName}'...`));
+    if (!options.skipArchive) {
+      const globalConfig = configManager.loadGlobalConfig();
+      if (globalConfig.autoArchive) {
+        console.log(pc.gray("Archiving current session..."));
+        await archiveCommand(domainName);
+      }
+    }
+    const newSessionId = SessionManager.generateSessionId(domainName, true);
+    const newState = {
+      ...state,
+      sessions: {
+        ...state.sessions
+      }
+    };
+    delete newState.sessions[domainName];
+    if (state.activeDomain === domainName) {
+      newState.activeDomain = null;
+      newState.activeSession = null;
+    }
+    configManager.saveState(newState);
+    console.log(pc.green(`\u2705 Domain '${domainName}' has been reset`));
+    console.log(pc.gray(`New session will be created on next switch`));
+    console.log(pc.gray(`Session ID: ${newSessionId.substring(0, 8)}...`));
+  } catch (error) {
+    console.error(pc.red(`\u274C Failed to reset domain: ${error}`));
+    process.exit(1);
+  }
+}
+export {
+  resetCommand
+};

package/dist/session-YAMF4YD7.js

@@ -0,0 +1,9 @@
+import {
+  SessionManager,
+  init_session
+} from "./chunk-UKMZ4CUZ.js";
+import "./chunk-PNKVD2UK.js";
+init_session();
+export {
+  SessionManager
+};

package/dist/switch-MWKYEYHE.js

@@ -0,0 +1,218 @@
+import {
+  processManager
+} from "./chunk-56TY2J6E.js";
+import {
+  configManager
+} from "./chunk-XGE4JP55.js";
+import {
+  SessionManager,
+  init_session
+} from "./chunk-UKMZ4CUZ.js";
+import {
+  paths
+} from "./chunk-A7YXSI66.js";
+import "./chunk-PNKVD2UK.js";
+
+// src/commands/switch.ts
+import picocolors from "picocolors";
+init_session();
+import { existsSync, writeFileSync, readFileSync, unlinkSync, copyFileSync, mkdirSync, readdirSync } from "fs";
+import { join, dirname, basename } from "path";
+var pc = picocolors;
+async function switchCommand(domainName, options = {}) {
+  try {
+    processSessionFallback();
+    console.log(pc.cyan(`\u{1F504} Switching to domain '${domainName}'...`));
+    if (!processManager.verifyClaudeInstalled()) {
+      printClaudeInstallHelp();
+      process.exit(1);
+    }
+    if (!configManager.domainExists(domainName)) {
+      throw new Error(`Domain '${domainName}' not found`);
+    }
+    const domain = configManager.loadDomain(domainName);
+    const state = configManager.loadState();
+    if (state.activeDomain === domainName && !options.force) {
+      console.log(pc.yellow(`Domain '${domainName}' is already active.`));
+      console.log(pc.gray("Use --force to restart the session."));
+      return;
+    }
+    console.log(pc.gray("Terminating existing Claude sessions..."));
+    await processManager.killAllClaudeProcesses();
+    if (state.activeDomain) {
+      processManager.deletePidFile(state.activeDomain);
+    }
+    let sessionId;
+    let isNewSession = false;
+    if (state.sessions?.[domainName] && !options.force) {
+      const session = state.sessions[domainName];
+      sessionId = session.sessionId;
+      const risk = SessionManager.getSessionRisk(session.started);
+      if (risk === "high" || risk === "critical") {
+        console.log(pc.yellow(`\u26A0\uFE0F  Session is ${SessionManager.getSessionAge(session.started)} old`));
+        console.log(pc.yellow('Consider using "cs reset" if you experience issues.'));
+      }
+      console.log(pc.gray(`Resuming session ${sessionId.substring(0, 8)}...`));
+    } else {
+      sessionId = SessionManager.generateSessionId(domainName, true);
+      isNewSession = true;
+      console.log(pc.gray(`Creating new session ${sessionId.substring(0, 8)}...`));
+    }
+    await updateMCPConfig(domain);
+    await handleMemoryFiles(domain);
+    console.log(pc.gray("Starting Claude with new configuration..."));
+    let pid;
+    if (!isNewSession) {
+      const fallbackSessionId = SessionManager.generateSessionId(domainName, true);
+      pid = spawnClaudeWithFallback(domain, sessionId, fallbackSessionId);
+    } else {
+      pid = processManager.spawnClaude(["--session-id", sessionId], {
+        cwd: domain.workingDirectory,
+        env: {
+          ...process.env,
+          ...domain.env
+        }
+      });
+    }
+    const newState = {
+      ...state,
+      activeDomain: domainName,
+      activeSession: sessionId,
+      lastSwitch: (/* @__PURE__ */ new Date()).toISOString(),
+      sessions: {
+        ...state.sessions,
+        [domainName]: SessionManager.createSessionRecord(domainName, sessionId, pid)
+      }
+    };
+    configManager.saveState(newState);
+    if (pid) {
+      processManager.writePidFile(domainName, pid);
+    }
+    console.log(pc.green(`\u2705 Switched to domain '${domainName}'`));
+    console.log(pc.gray(`Working directory: ${domain.workingDirectory}`));
+    if (domain.mcpServers && Object.keys(domain.mcpServers).length > 0) {
+      console.log(pc.gray(`MCP servers: ${Object.keys(domain.mcpServers).join(", ")}`));
+    }
+  } catch (error) {
+    console.error(pc.red(`\u274C Failed to switch domain: ${error}`));
+    process.exit(1);
+  }
+}
+async function updateMCPConfig(domain) {
+  const mcpConfigPath = paths.claudeMCPConfig;
+  const mcpDir = dirname(mcpConfigPath);
+  if (!existsSync(mcpDir)) {
+    mkdirSync(mcpDir, { recursive: true });
+  }
+  const mcpConfig = {
+    servers: domain.mcpServers || {}
+  };
+  writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+  console.log(pc.gray("Updated MCP configuration"));
+}
+async function handleMemoryFiles(domain) {
+  if (!domain.claudeConfig?.memory || domain.claudeConfig.memory.length === 0) {
+    return;
+  }
+  const claudeDir = paths.claudeConfigDir;
+  const memoryDir = join(claudeDir, "memory");
+  if (!existsSync(memoryDir)) {
+    mkdirSync(memoryDir, { recursive: true });
+  }
+  if (existsSync(memoryDir)) {
+    const files = readdirSync(memoryDir);
+    for (const file of files) {
+      unlinkSync(join(memoryDir, file));
+    }
+  }
+  for (const memoryPath of domain.claudeConfig.memory) {
+    const expandedPath = paths.expandPath(memoryPath);
+    if (!existsSync(expandedPath)) {
+      console.log(pc.yellow(`Warning: Memory file not found: ${memoryPath}`));
+      continue;
+    }
+    const fileName = basename(expandedPath);
+    const destPath = join(memoryDir, fileName);
+    copyFileSync(expandedPath, destPath);
+    console.log(pc.gray(`Loaded memory file: ${fileName}`));
+  }
+}
+function spawnClaudeWithFallback(domain, resumeSessionId, fallbackSessionId) {
+  const claudeCmd = processManager.getClaudeExecutable();
+  if (!claudeCmd) {
+    throw new Error("Claude CLI not found");
+  }
+  const cwd = domain.workingDirectory;
+  const markerFile = getSessionFallbackPath();
+  const domainName = domain.name;
+  const envLines = domain.env ? Object.entries(domain.env).map(([k, v]) => `export ${k}="${v}"`).join("\n") : "";
+  const markerJson = JSON.stringify({ domain: domainName, sessionId: fallbackSessionId });
+  const script = [
+    "#!/bin/bash",
+    `cd "${cwd}"`,
+    envLines,
+    "",
+    "# Try to resume the existing session",
+    `"${claudeCmd}" --resume "${resumeSessionId}"`,
+    "RESUME_EXIT=$?",
+    "",
+    "# If resume failed (non-zero exit), fall back to a new session",
+    "if [ $RESUME_EXIT -ne 0 ]; then",
+    '  echo ""',
+    '  echo "Previous session could not be resumed. Starting a fresh session..."',
+    '  echo ""',
+    "",
+    "  # Write marker so cs can update state with the new session ID",
+    `  echo '${markerJson}' > "${markerFile}"`,
+    "",
+    `  "${claudeCmd}" --session-id "${fallbackSessionId}"`,
+    "fi"
+  ].join("\n");
+  return processManager.spawnTerminalScript(script, cwd);
+}
+function getSessionFallbackPath() {
+  return join(paths.baseDir, "session-fallback.json");
+}
+function processSessionFallback() {
+  const markerPath = getSessionFallbackPath();
+  if (!existsSync(markerPath)) {
+    return;
+  }
+  try {
+    const content = readFileSync(markerPath, "utf-8");
+    const marker = JSON.parse(content);
+    if (marker.domain && marker.sessionId) {
+      const state = configManager.loadState();
+      if (state.sessions?.[marker.domain]) {
+        state.sessions[marker.domain].sessionId = marker.sessionId;
+        state.sessions[marker.domain].started = (/* @__PURE__ */ new Date()).toISOString();
+        state.sessions[marker.domain].lastActive = (/* @__PURE__ */ new Date()).toISOString();
+        state.activeSession = marker.sessionId;
+        configManager.saveState(state);
+        console.log(pc.yellow(`Note: Previous session for '${marker.domain}' could not be resumed.`));
+        console.log(pc.yellow(`A new session (${marker.sessionId.substring(0, 8)}...) was started automatically.
+`));
+      }
+    }
+    unlinkSync(markerPath);
+  } catch {
+    try {
+      unlinkSync(markerPath);
+    } catch {
+    }
+  }
+}
+function printClaudeInstallHelp() {
+  console.error(pc.red("\u274C Claude Code CLI not found\n"));
+  console.log(pc.white("ContextSwitch requires the Claude Code CLI to be installed.\n"));
+  console.log(pc.cyan("Install via npm (recommended):"));
+  console.log(pc.gray("  npm install -g @anthropic-ai/claude-code\n"));
+  console.log(pc.cyan("Or see the official docs:"));
+  console.log(pc.gray("  https://docs.anthropic.com/en/docs/claude-code\n"));
+  console.log(pc.white("After installing, verify it works:"));
+  console.log(pc.gray("  claude --version\n"));
+  console.log(pc.gray("Then try your command again."));
+}
+export {
+  switchCommand
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "contextswitch",
+  "version": "0.1.1",
+  "description": "Domain-based context management for Claude Code CLI",
+  "main": "dist/cli.js",
+  "type": "module",
+  "bin": {
+    "cs": "./dist/cli.js",
+    "contextswitch": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "preferGlobal": true,
+  "scripts": {
+    "dev": "bun run src/cli.ts",
+    "build": "bun build src/cli.ts --compile --outfile cs",
+    "build:node": "tsup src/cli.ts --format esm --target node18",
+    "prepublishOnly": "npm run build:node",
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write src/**/*.ts"
+  },
+  "keywords": [
+    "claude",
+    "cli",
+    "context",
+    "domain",
+    "mcp",
+    "session"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^11.1.0",
+    "yaml": "^2.3.4",
+    "zod": "^3.22.4",
+    "uuid": "^9.0.1",
+    "picocolors": "^1.0.0",
+    "enquirer": "^2.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/uuid": "^9.0.7",
+    "typescript": "^5.3.3",
+    "vitest": "^1.0.4",
+    "tsup": "^8.0.1",
+    "@vitest/coverage-v8": "^1.0.4",
+    "eslint": "^8.55.0",
+    "@typescript-eslint/eslint-plugin": "^6.14.0",
+    "@typescript-eslint/parser": "^6.14.0",
+    "prettier": "^3.1.1"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "bun": ">=1.0.0"
+  }
+}