contextswitch 0.1.1

package/README.md

@@ -0,0 +1,185 @@
+# ContextSwitch
+
+Domain-based context management for Claude Code CLI. Switch between different project contexts while preserving session history.
+
+## Features
+
+✅ **Session Persistence** - Resume previous Claude sessions when switching domains
+✅ **Domain Management** - Organize projects with separate configurations
+✅ **MCP Server Support** - Configure Model Context Protocol servers per domain
+✅ **Cross-Platform** - Works on macOS, Linux, and Windows
+✅ **Session Archives** - Save and restore session snapshots
+✅ **Process Management** - Clean switching between Claude instances
+
+## Installation
+
+### Quick Install
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/contextswitch.git
+cd contextswitch
+
+# Run the installation script
+chmod +x install.sh
+./install.sh
+```
+
+This sets up the `cs` command for easy use. For other installation methods, see [INSTALLATION.md](INSTALLATION.md).
+
+### Manual Install
+```bash
+# Install dependencies
+npm install
+
+# Build the project
+npm run build:node
+
+# Add alias to your shell
+echo "alias cs='node $(pwd)/dist/cli.js'" >> ~/.zshrc
+source ~/.zshrc
+
+# Now you can use 'cs' command
+cs --help
+```
+
+## Quick Start
+
+```bash
+# Initialize ContextSwitch
+node dist/cli.js init
+
+# Create a new domain for your project (working directory is REQUIRED)
+node dist/cli.js domain add backend --working-dir ~/projects/api
+
+# The working directory is where Claude will operate when you switch to this domain
+node dist/cli.js switch backend
+
+# Check status
+node dist/cli.js status
+
+# List all domains
+node dist/cli.js list
+```
+
+## Commands
+
+### Core Commands
+
+- `cs init` - Initialize ContextSwitch configuration
+- `cs switch <domain>` - Switch to a different domain
+- `cs list` - List all available domains
+- `cs status [domain]` - Show current domain and session status
+
+### Domain Management
+
+- `cs domain add <name>` - Create a new domain
+- `cs domain remove <name>` - Delete a domain
+- `cs reset <domain>` - Reset domain session (with auto-archive)
+- `cs archive <domain>` - Archive current session
+
+### Diagnostics
+
+- `cs doctor` - Check system configuration
+- `cs --help` - Show help information
+- `cs --version` - Show version
+
+## Domain Configuration
+
+Domains are stored as YAML files in the configuration directory. Example domain:
+
+```yaml
+name: backend
+workingDirectory: ~/projects/api
+
+claudeConfig:
+  instructions: ./CLAUDE.md
+  memory:
+    - ./context/api-overview.md
+
+mcpServers:
+  filesystem:
+    command: npx
+    args: ["-y", "@modelcontextprotocol/server-filesystem"]
+    env:
+      DIRECTORY: "./"
+
+env:
+  NODE_ENV: development
+```
+
+## Project Structure
+
+```
+contextswitch/
+├── src/
+│   ├── cli.ts              # Main CLI entry point
+│   ├── commands/           # Command implementations
+│   │   ├── switch.ts       # Domain switching logic
+│   │   ├── reset.ts        # Session reset
+│   │   └── archive.ts      # Session archiving
+│   └── core/               # Core modules
+│       ├── domain.ts       # Domain schemas (Zod)
+│       ├── config.ts       # Configuration management
+│       ├── session.ts      # Session ID generation
+│       ├── process.ts      # Process management
+│       └── paths.ts        # Cross-platform paths
+├── domains/                # Domain templates
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+## Configuration Files
+
+- **Domains**: `~/Library/Application Support/contextswitch/domains/*.yml` (macOS)
+- **State**: `~/Library/Application Support/contextswitch/state.json`
+- **Archives**: `~/Library/Application Support/contextswitch/archives/`
+
+## Development
+
+```bash
+# Run TypeScript compiler check
+npx tsc --noEmit
+
+# Run in development mode
+npm run dev
+
+# Build for production
+npm run build:node
+
+# Run tests (when implemented)
+npm test
+```
+
+## Technical Details
+
+- Built with TypeScript and Commander.js
+- Uses Zod for runtime validation
+- Deterministic session IDs via UUID v5
+- Atomic file operations for data safety
+- Cross-platform process management
+
+## Status
+
+**Current Version**: 0.1.0 (MVP)
+
+### Implemented
+- ✅ Core domain management
+- ✅ Session persistence with `--resume`
+- ✅ Process management (kill/spawn Claude)
+- ✅ State tracking and atomic writes
+- ✅ Cross-platform path resolution
+- ✅ Basic CLI commands
+- ✅ Archive functionality
+
+### Not Yet Implemented
+- ⏳ Git sync for team sharing
+- ⏳ Token usage estimation
+- ⏳ Advanced diagnostics
+- ⏳ Binary compilation with Bun
+- ⏳ Automated tests
+- ⏳ Shell integration scripts
+
+## License
+
+MIT

package/dist/archive-3IGWZBSO.js

@@ -0,0 +1,12 @@
+import {
+  archiveCommand,
+  listArchives
+} from "./chunk-2LUEUGBV.js";
+import "./chunk-XGE4JP55.js";
+import "./chunk-UKMZ4CUZ.js";
+import "./chunk-A7YXSI66.js";
+import "./chunk-PNKVD2UK.js";
+export {
+  archiveCommand,
+  listArchives
+};

package/dist/chunk-2LUEUGBV.js

@@ -0,0 +1,110 @@
+import {
+  configManager
+} from "./chunk-XGE4JP55.js";
+import {
+  init_session,
+  session_exports
+} from "./chunk-UKMZ4CUZ.js";
+import {
+  paths
+} from "./chunk-A7YXSI66.js";
+import {
+  __toCommonJS
+} from "./chunk-PNKVD2UK.js";
+
+// src/commands/archive.ts
+import picocolors from "picocolors";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, statSync, readdirSync } from "fs";
+import { join, basename } from "path";
+var pc = picocolors;
+async function archiveCommand(domainName) {
+  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 archive.`));
+      return;
+    }
+    console.log(pc.cyan(`\u{1F4E6} Archiving session for domain '${domainName}'...`));
+    const archiveDir = join(paths.archivesDir, domainName);
+    if (!existsSync(archiveDir)) {
+      mkdirSync(archiveDir, { recursive: true });
+    }
+    const timestamp = /* @__PURE__ */ new Date();
+    const archiveMetadata = {
+      domain: domainName,
+      session,
+      timestamp: timestamp.toISOString(),
+      config: configManager.loadDomain(domainName)
+    };
+    const dateStr = timestamp.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, -5);
+    const archiveName = `${dateStr}.json`;
+    const archivePath = join(archiveDir, archiveName);
+    writeFileSync(archivePath, JSON.stringify(archiveMetadata, null, 2), "utf-8");
+    const domain = configManager.loadDomain(domainName);
+    if (domain.claudeConfig?.memory) {
+      const memoryArchiveDir = join(archiveDir, dateStr, "memory");
+      mkdirSync(memoryArchiveDir, { recursive: true });
+      for (const memoryFile of domain.claudeConfig.memory) {
+        const expandedPath = paths.expandPath(memoryFile);
+        if (existsSync(expandedPath)) {
+          const fileName = basename(expandedPath);
+          const destPath = join(memoryArchiveDir, fileName);
+          const content = readFileSync(expandedPath, "utf-8");
+          writeFileSync(destPath, content, "utf-8");
+        }
+      }
+    }
+    const stats = statSync(archivePath);
+    const sizeKB = Math.round(stats.size / 1024);
+    console.log(pc.green(`\u2705 Session archived successfully`));
+    console.log(pc.gray(`Archive: ${archivePath}`));
+    console.log(pc.gray(`Size: ${sizeKB} KB`));
+    console.log(pc.gray(`Session age: ${(init_session(), __toCommonJS(session_exports)).SessionManager.getSessionAge(session.started)}`));
+  } catch (error) {
+    console.error(pc.red(`\u274C Failed to archive session: ${error}`));
+    process.exit(1);
+  }
+}
+function listArchives(domainName) {
+  const archiveDir = join(paths.archivesDir, domainName);
+  if (!existsSync(archiveDir)) {
+    console.log(pc.yellow(`No archives found for domain '${domainName}'`));
+    return [];
+  }
+  const files = readdirSync(archiveDir).filter((file) => file.endsWith(".json")).sort().reverse();
+  if (files.length === 0) {
+    console.log(pc.yellow(`No archives found for domain '${domainName}'`));
+    return [];
+  }
+  console.log(pc.cyan(`\u{1F4E6} Archives for domain '${domainName}':
+`));
+  const archives = [];
+  for (const file of files.slice(0, 10)) {
+    const archivePath = join(archiveDir, file);
+    try {
+      const content = readFileSync(archivePath, "utf-8");
+      const metadata = JSON.parse(content);
+      const date = new Date(metadata.timestamp);
+      const dateStr = date.toLocaleDateString() + " " + date.toLocaleTimeString();
+      console.log(`  ${dateStr}`);
+      console.log(pc.gray(`    Session: ${metadata.session.sessionId.substring(0, 8)}...`));
+      console.log(pc.gray(`    File: ${file}`));
+      archives.push(metadata);
+    } catch {
+    }
+  }
+  if (files.length > 10) {
+    console.log(pc.gray(`
+  ... and ${files.length - 10} more`));
+  }
+  return archives;
+}
+
+export {
+  archiveCommand,
+  listArchives
+};

package/dist/chunk-56TY2J6E.js

@@ -0,0 +1,366 @@
+import {
+  paths
+} from "./chunk-A7YXSI66.js";
+
+// src/core/process.ts
+import { execSync, spawn } from "child_process";
+import { platform } from "os";
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { join } from "path";
+var ProcessManager = class {
+  platform = platform();
+  /**
+   * Find all Claude Code processes
+   */
+  findClaudeProcesses() {
+    try {
+      switch (this.platform) {
+        case "darwin":
+        case "linux":
+          return this.findUnixProcesses();
+        case "win32":
+          return this.findWindowsProcesses();
+        default:
+          throw new Error(`Unsupported platform: ${this.platform}`);
+      }
+    } catch (error) {
+      console.error(`Failed to find processes: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Find processes on Unix-like systems
+   */
+  findUnixProcesses() {
+    try {
+      const output = execSync("ps aux", { encoding: "utf-8" });
+      const lines = output.split("\n");
+      const processes = [];
+      for (const line of lines) {
+        if (line.includes("claude") && !line.includes("cs switch")) {
+          const parts = line.split(/\s+/);
+          if (parts.length >= 11 && parts[1]) {
+            const pid = parseInt(parts[1], 10);
+            const command = parts[10] || "";
+            const args = parts.slice(11);
+            if (command && (command.includes("claude") || args.some((arg) => arg && arg.includes("claude")))) {
+              processes.push({ pid, command, args });
+            }
+          }
+        }
+      }
+      return processes;
+    } catch (error) {
+      console.error(`Unix process detection failed: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Find processes on Windows using PowerShell (wmic is deprecated)
+   */
+  findWindowsProcesses() {
+    try {
+      const output = execSync(
+        `powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -like '*claude*' } | Select-Object ProcessId,CommandLine | ConvertTo-Csv -NoTypeInformation"`,
+        { encoding: "utf-8" }
+      );
+      const lines = output.split("\r\n").filter((line) => line.trim());
+      const processes = [];
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line) continue;
+        const match = line.match(/^"?(\d+)"?,"?(.*?)"?$/);
+        if (match) {
+          const pid = parseInt(match[1], 10);
+          const commandLine = match[2] || "";
+          if (commandLine.includes("claude") && !commandLine.includes("cs switch")) {
+            processes.push({
+              pid,
+              command: "claude",
+              args: commandLine.split(" ").slice(1)
+            });
+          }
+        }
+      }
+      return processes;
+    } catch (error) {
+      console.error(`Windows process detection failed: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Kill a process by PID
+   */
+  killProcess(pid, force = false) {
+    try {
+      if (this.platform === "win32") {
+        const flag = force ? "/F" : "";
+        execSync(`taskkill /PID ${pid} ${flag}`, { stdio: "ignore" });
+      } else {
+        const signal = force ? "SIGKILL" : "SIGTERM";
+        process.kill(pid, signal);
+      }
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Kill all Claude processes (with timeout for graceful shutdown)
+   */
+  async killAllClaudeProcesses(timeout = 5e3) {
+    const processes = this.findClaudeProcesses();
+    if (processes.length === 0) {
+      return;
+    }
+    console.log(`Found ${processes.length} Claude process(es) to terminate`);
+    for (const proc of processes) {
+      this.killProcess(proc.pid, false);
+    }
+    await new Promise((resolve) => setTimeout(resolve, Math.min(timeout, 1e3)));
+    const remaining = this.findClaudeProcesses();
+    for (const proc of remaining) {
+      console.log(`Force killing process ${proc.pid}`);
+      this.killProcess(proc.pid, true);
+    }
+  }
+  /**
+   * Spawn Claude with specific arguments
+   */
+  spawnClaude(args, options) {
+    const claudeCmd = this.findClaudeExecutable();
+    if (!claudeCmd) {
+      throw new Error("Claude CLI not found. Please ensure it is installed and in your PATH.");
+    }
+    if (this.platform === "darwin") {
+      const cwd = options?.cwd || process.cwd();
+      const claudeCommand = `cd "${cwd}" && ${claudeCmd} ${args.join(" ")}`;
+      const script = `tell app "Terminal" to do script "${claudeCommand.replace(/"/g, '\\"')}"`;
+      const terminalProcess = spawn("osascript", ["-e", script], {
+        detached: true,
+        stdio: "ignore"
+      });
+      terminalProcess.unref();
+      return terminalProcess.pid || 0;
+    }
+    if (this.platform === "linux") {
+      const cwd = options?.cwd || process.cwd();
+      const claudeCommand = `${claudeCmd} ${args.join(" ")}`;
+      const terminals = ["gnome-terminal", "xterm", "konsole", "xfce4-terminal"];
+      for (const term of terminals) {
+        try {
+          const termProcess = spawn(term, ["--", "bash", "-c", `cd "${cwd}" && ${claudeCommand}`], {
+            detached: true,
+            stdio: "ignore"
+          });
+          termProcess.unref();
+          return termProcess.pid || 0;
+        } catch {
+        }
+      }
+    }
+    if (this.platform === "win32") {
+      const cwd = options?.cwd || process.cwd();
+      const gitBash = this.findGitBash();
+      if (gitBash) {
+        const claudeCommand = `cd "${cwd.replace(/\\/g, "/")}" && ${claudeCmd} ${args.join(" ")}`;
+        const cmdProcess = spawn("cmd.exe", ["/c", "start", "", gitBash, "-c", claudeCommand], {
+          detached: true,
+          stdio: "ignore",
+          windowsHide: false
+        });
+        cmdProcess.unref();
+        return cmdProcess.pid || 0;
+      } else {
+        const claudeCommand = `cd /d "${cwd}" && ${claudeCmd} ${args.join(" ")}`;
+        const cmdProcess = spawn("cmd.exe", ["/c", "start", "cmd.exe", "/k", claudeCommand], {
+          detached: true,
+          stdio: "ignore",
+          windowsHide: false
+        });
+        cmdProcess.unref();
+        return cmdProcess.pid || 0;
+      }
+    }
+    const claudeProcess = spawn(claudeCmd, args, {
+      detached: true,
+      stdio: "ignore",
+      ...options
+    });
+    claudeProcess.unref();
+    return claudeProcess.pid || 0;
+  }
+  /**
+   * Spawn a shell script in a new terminal window
+   */
+  spawnTerminalScript(script, cwd) {
+    const scriptFile = join(paths.baseDir, "launch.sh");
+    writeFileSync(scriptFile, script, { mode: 493 });
+    if (this.platform === "darwin") {
+      const escapedPath = scriptFile.replace(/"/g, '\\"');
+      const appleScript = `tell app "Terminal" to do script "bash \\"${escapedPath}\\""`;
+      const proc2 = spawn("osascript", ["-e", appleScript], {
+        detached: true,
+        stdio: "ignore"
+      });
+      proc2.unref();
+      return proc2.pid || 0;
+    }
+    if (this.platform === "linux") {
+      const terminals = ["gnome-terminal", "xterm", "konsole", "xfce4-terminal"];
+      for (const term of terminals) {
+        try {
+          const proc2 = spawn(term, ["--", "bash", scriptFile], {
+            detached: true,
+            stdio: "ignore"
+          });
+          proc2.unref();
+          return proc2.pid || 0;
+        } catch {
+        }
+      }
+    }
+    if (this.platform === "win32") {
+      const gitBash = this.findGitBash();
+      const bashCmd = gitBash || "bash";
+      const scriptPath = scriptFile.replace(/\\/g, "/");
+      const proc2 = spawn("cmd.exe", ["/c", "start", "", bashCmd, scriptPath], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: false
+      });
+      proc2.unref();
+      return proc2.pid || 0;
+    }
+    const proc = spawn("bash", [scriptFile], {
+      detached: true,
+      stdio: "ignore"
+    });
+    proc.unref();
+    return proc.pid || 0;
+  }
+  /**
+   * Get the Claude executable path (public accessor)
+   */
+  getClaudeExecutable() {
+    return this.findClaudeExecutable();
+  }
+  /**
+   * Find Git Bash executable on Windows
+   */
+  findGitBash() {
+    if (this.platform !== "win32") return null;
+    const candidates = [
+      join(process.env.PROGRAMFILES || "C:\\Program Files", "Git", "bin", "bash.exe"),
+      join(process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)", "Git", "bin", "bash.exe"),
+      join(process.env.LOCALAPPDATA || "", "Programs", "Git", "bin", "bash.exe"),
+      "C:\\Program Files\\Git\\bin\\bash.exe"
+    ];
+    for (const candidate of candidates) {
+      if (candidate && existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    try {
+      const output = execSync("where bash", { encoding: "utf-8" }).trim();
+      const firstLine = output.split("\n")[0]?.trim();
+      if (firstLine && firstLine.toLowerCase().includes("git")) {
+        return firstLine;
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Find Claude executable path
+   */
+  findClaudeExecutable() {
+    try {
+      if (this.platform === "win32") {
+        const output = execSync("where claude", { encoding: "utf-8" }).trim();
+        const firstLine = output.split("\n")[0];
+        return firstLine || null;
+      } else {
+        const output = execSync("which claude", { encoding: "utf-8" }).trim();
+        return output || null;
+      }
+    } catch {
+      const commonPaths = this.platform === "win32" ? [
+        join(process.env.LOCALAPPDATA || "", "Programs", "Claude Code", "claude.exe"),
+        join(process.env.PROGRAMFILES || "C:\\Program Files", "Claude Code", "claude.exe"),
+        join(process.env.PROGRAMFILES || "C:\\Program Files", "Claude", "claude.exe"),
+        "C:\\Program Files\\Claude Code\\claude.exe",
+        "C:\\Program Files\\Claude\\claude.exe"
+      ] : [
+        "/usr/local/bin/claude",
+        "/usr/bin/claude",
+        "/opt/homebrew/bin/claude"
+      ];
+      for (const candidatePath of commonPaths) {
+        if (candidatePath && existsSync(candidatePath)) {
+          return candidatePath;
+        }
+      }
+      return null;
+    }
+  }
+  /**
+   * Write PID file for tracking
+   */
+  writePidFile(domainName, pid) {
+    const pidFile = join(paths.baseDir, `${domainName}.pid`);
+    writeFileSync(pidFile, pid.toString(), "utf-8");
+  }
+  /**
+   * Read PID file
+   */
+  readPidFile(domainName) {
+    const pidFile = join(paths.baseDir, `${domainName}.pid`);
+    if (!existsSync(pidFile)) {
+      return null;
+    }
+    try {
+      const content = readFileSync(pidFile, "utf-8");
+      return parseInt(content, 10);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Delete PID file
+   */
+  deletePidFile(domainName) {
+    const pidFile = join(paths.baseDir, `${domainName}.pid`);
+    if (existsSync(pidFile)) {
+      unlinkSync(pidFile);
+    }
+  }
+  /**
+   * Check if a process is still running
+   */
+  isProcessRunning(pid) {
+    try {
+      if (this.platform === "win32") {
+        const output = execSync(`tasklist /FI "PID eq ${pid}"`, { encoding: "utf-8" });
+        return output.includes(pid.toString());
+      } else {
+        process.kill(pid, 0);
+        return true;
+      }
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Verify Claude is installed
+   */
+  verifyClaudeInstalled() {
+    return this.findClaudeExecutable() !== null;
+  }
+};
+var processManager = new ProcessManager();
+
+export {
+  ProcessManager,
+  processManager
+};