contextswitch 0.1.1

package/dist/chunk-A7YXSI66.js

@@ -0,0 +1,163 @@
+// src/core/paths.ts
+import { homedir, platform } from "os";
+import { join, resolve, normalize } from "path";
+import { existsSync, mkdirSync } from "fs";
+var Paths = class _Paths {
+  static _instance;
+  _baseDir;
+  _platform;
+  constructor() {
+    this._platform = platform();
+    this._baseDir = this.getDefaultBaseDir();
+  }
+  static get instance() {
+    if (!this._instance) {
+      this._instance = new _Paths();
+    }
+    return this._instance;
+  }
+  /**
+   * Get the default base directory for ContextSwitch config
+   */
+  getDefaultBaseDir() {
+    const home = homedir();
+    switch (this._platform) {
+      case "win32":
+        const appData = process.env.APPDATA || join(home, "AppData", "Roaming");
+        return join(appData, "contextswitch");
+      case "darwin":
+        return join(home, "Library", "Application Support", "contextswitch");
+      default:
+        const xdgConfig = process.env.XDG_CONFIG_HOME || join(home, ".config");
+        return join(xdgConfig, "contextswitch");
+    }
+  }
+  /**
+   * Override base directory (useful for testing)
+   */
+  setBaseDir(dir) {
+    this._baseDir = resolve(dir);
+  }
+  /**
+   * Get base configuration directory
+   */
+  get baseDir() {
+    return this._baseDir;
+  }
+  /**
+   * Get domains directory
+   */
+  get domainsDir() {
+    return join(this._baseDir, "domains");
+  }
+  /**
+   * Get archives directory
+   */
+  get archivesDir() {
+    return join(this._baseDir, "archives");
+  }
+  /**
+   * Get state file path
+   */
+  get stateFile() {
+    return join(this._baseDir, "state.json");
+  }
+  /**
+   * Get global config file path
+   */
+  get globalConfigFile() {
+    return join(this._baseDir, "config.yml");
+  }
+  /**
+   * Get domain config file path
+   */
+  domainConfigFile(domainName) {
+    return join(this.domainsDir, `${domainName}.yml`);
+  }
+  /**
+   * Get archive file path for a domain
+   */
+  archiveFile(domainName, timestamp) {
+    const ts = timestamp || /* @__PURE__ */ new Date();
+    const dateStr = ts.toISOString().replace(/[:.]/g, "-");
+    return join(this.archivesDir, domainName, `${dateStr}.tar.gz`);
+  }
+  /**
+   * Get Claude config directory
+   */
+  get claudeConfigDir() {
+    const home = homedir();
+    switch (this._platform) {
+      case "win32":
+        const appData = process.env.APPDATA || join(home, "AppData", "Roaming");
+        return join(appData, "Claude");
+      case "darwin":
+        return join(home, "Library", "Application Support", "Claude");
+      default:
+        const xdgConfig = process.env.XDG_CONFIG_HOME || join(home, ".config");
+        return join(xdgConfig, "claude");
+    }
+  }
+  /**
+   * Get MCP config file path for Claude
+   */
+  get claudeMCPConfig() {
+    return join(this.claudeConfigDir, "mcp", "config.json");
+  }
+  /**
+   * Expand environment variables and ~ in paths
+   */
+  expandPath(inputPath) {
+    if (inputPath.startsWith("~/")) {
+      inputPath = join(homedir(), inputPath.slice(2));
+    }
+    inputPath = inputPath.replace(/\$([A-Z_][A-Z0-9_]*)/gi, (match, varName) => {
+      return process.env[varName] || match;
+    });
+    return normalize(resolve(inputPath));
+  }
+  /**
+   * Ensure all required directories exist
+   */
+  ensureDirectories() {
+    const dirs = [
+      this.baseDir,
+      this.domainsDir,
+      this.archivesDir
+    ];
+    for (const dir of dirs) {
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+    }
+  }
+  /**
+   * Check if running on Windows
+   */
+  get isWindows() {
+    return this._platform === "win32";
+  }
+  /**
+   * Check if running on macOS
+   */
+  get isMacOS() {
+    return this._platform === "darwin";
+  }
+  /**
+   * Check if running on Linux
+   */
+  get isLinux() {
+    return this._platform === "linux";
+  }
+  /**
+   * Get platform name
+   */
+  get platform() {
+    return this._platform;
+  }
+};
+var paths = Paths.instance;
+
+export {
+  paths
+};

package/dist/chunk-PNKVD2UK.js

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __esm,
+  __export,
+  __toCommonJS
+};

package/dist/chunk-UKMZ4CUZ.js

@@ -0,0 +1,116 @@
+import {
+  __esm,
+  __export
+} from "./chunk-PNKVD2UK.js";
+
+// src/core/session.ts
+var session_exports = {};
+__export(session_exports, {
+  SessionManager: () => SessionManager
+});
+import { v5 as uuidv5 } from "uuid";
+import { createHash } from "crypto";
+var SessionManager;
+var init_session = __esm({
+  "src/core/session.ts"() {
+    SessionManager = class {
+      // Namespace UUID for ContextSwitch sessions
+      static NAMESPACE = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+      /**
+       * Generate a deterministic session ID for a domain
+       * Uses UUID v5 to ensure same domain always gets same base session ID
+       */
+      static generateSessionId(domainName, reset = false) {
+        const seed = reset ? `${domainName}:${Date.now()}` : domainName;
+        return uuidv5(seed, this.NAMESPACE);
+      }
+      /**
+       * Generate a session hash for verification
+       * Useful for checking if a session is still valid
+       */
+      static generateSessionHash(sessionId, domainName) {
+        const hash = createHash("sha256");
+        hash.update(`${sessionId}:${domainName}`);
+        return hash.digest("hex").substring(0, 8);
+      }
+      /**
+       * Create a session record
+       */
+      static createSessionRecord(domainName, sessionId, processId) {
+        return {
+          domain: domainName,
+          sessionId,
+          started: (/* @__PURE__ */ new Date()).toISOString(),
+          lastActive: (/* @__PURE__ */ new Date()).toISOString(),
+          processId
+        };
+      }
+      /**
+       * Check if a session is likely expired based on age
+       * Claude sessions typically last 1-2 weeks
+       */
+      static isSessionLikelyExpired(startedAt) {
+        const started = new Date(startedAt);
+        const now = /* @__PURE__ */ new Date();
+        const daysSinceStart = (now.getTime() - started.getTime()) / (1e3 * 60 * 60 * 24);
+        return daysSinceStart > 7;
+      }
+      /**
+       * Get session age in human-readable format
+       */
+      static getSessionAge(startedAt) {
+        const started = new Date(startedAt);
+        const now = /* @__PURE__ */ new Date();
+        const diffMs = now.getTime() - started.getTime();
+        const days = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+        const hours = Math.floor(diffMs % (1e3 * 60 * 60 * 24) / (1e3 * 60 * 60));
+        if (days > 0) {
+          return `${days} day${days === 1 ? "" : "s"}, ${hours} hour${hours === 1 ? "" : "s"}`;
+        }
+        if (hours > 0) {
+          return `${hours} hour${hours === 1 ? "" : "s"}`;
+        }
+        const minutes = Math.floor(diffMs / (1e3 * 60));
+        return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+      }
+      /**
+       * Get session risk level based on age
+       */
+      static getSessionRisk(startedAt) {
+        const started = new Date(startedAt);
+        const now = /* @__PURE__ */ new Date();
+        const daysSinceStart = (now.getTime() - started.getTime()) / (1e3 * 60 * 60 * 24);
+        if (daysSinceStart < 3) return "low";
+        if (daysSinceStart < 5) return "medium";
+        if (daysSinceStart < 7) return "high";
+        return "critical";
+      }
+      /**
+       * Format session info for display
+       */
+      static formatSessionInfo(session) {
+        const age = this.getSessionAge(session.started);
+        const risk = this.getSessionRisk(session.started);
+        const riskColors = {
+          low: "\u{1F7E2}",
+          medium: "\u{1F7E1}",
+          high: "\u{1F7E0}",
+          critical: "\u{1F534}"
+        };
+        return [
+          `Domain: ${session.domain}`,
+          `Session ID: ${session.sessionId.substring(0, 8)}...`,
+          `Age: ${age}`,
+          `Risk: ${riskColors[risk]} ${risk}`,
+          risk === "high" || risk === "critical" ? "\u26A0\uFE0F  Consider resetting soon" : ""
+        ].filter(Boolean).join("\n");
+      }
+    };
+  }
+});
+
+export {
+  SessionManager,
+  session_exports,
+  init_session
+};

package/dist/chunk-XGE4JP55.js

@@ -0,0 +1,303 @@
+import {
+  paths
+} from "./chunk-A7YXSI66.js";
+
+// src/core/config.ts
+import { readFileSync, existsSync, writeFileSync, readdirSync, renameSync, unlinkSync } from "fs";
+import { parse, stringify } from "yaml";
+
+// src/core/domain.ts
+import { z } from "zod";
+var MCPServerSchema = z.object({
+  command: z.string().describe("Command to execute the MCP server"),
+  args: z.array(z.string()).optional().describe("Arguments for the command"),
+  env: z.record(z.string()).optional().describe("Environment variables")
+});
+var DomainConfigSchema = z.object({
+  name: z.string().min(1).describe("Domain identifier"),
+  workingDirectory: z.string().describe("Working directory for this domain"),
+  claudeConfig: z.object({
+    instructions: z.string().optional().describe("Path to CLAUDE.md file"),
+    memory: z.array(z.string()).optional().describe("Memory file paths")
+  }).optional(),
+  mcpServers: z.record(MCPServerSchema).optional().describe("MCP server configurations"),
+  env: z.record(z.string()).optional().describe("Environment variables for this domain"),
+  extends: z.string().optional().describe("Parent domain to inherit from"),
+  metadata: z.object({
+    description: z.string().optional(),
+    created: z.string().datetime().optional(),
+    lastUsed: z.string().datetime().optional(),
+    tags: z.array(z.string()).optional()
+  }).optional()
+});
+var StateSchema = z.object({
+  version: z.literal("1.0.0"),
+  activeDomain: z.string().nullable(),
+  activeSession: z.string().nullable(),
+  lastSwitch: z.string().datetime().optional(),
+  sessions: z.record(z.object({
+    domain: z.string(),
+    sessionId: z.string(),
+    started: z.string().datetime(),
+    lastActive: z.string().datetime(),
+    processId: z.number().optional()
+  })).optional()
+});
+var GlobalConfigSchema = z.object({
+  version: z.literal("1.0.0"),
+  defaultDomain: z.string().default("default"),
+  autoArchive: z.boolean().default(true),
+  archiveDirectory: z.string().optional(),
+  claudePath: z.string().optional().describe("Path to Claude CLI executable"),
+  logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  platform: z.object({
+    forceType: z.enum(["darwin", "linux", "win32"]).optional(),
+    killSignal: z.enum(["SIGTERM", "SIGKILL"]).default("SIGTERM"),
+    killTimeout: z.number().default(5e3).describe("Milliseconds to wait before force kill")
+  }).optional()
+});
+var DEFAULT_DOMAIN_TEMPLATE = {
+  name: "default",
+  workingDirectory: process.cwd(),
+  claudeConfig: {
+    instructions: "./CLAUDE.md"
+  },
+  mcpServers: {},
+  env: {},
+  metadata: {
+    description: "Default domain",
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    tags: []
+  }
+};
+function validateDomain(data) {
+  return DomainConfigSchema.parse(data);
+}
+function validateState(data) {
+  return StateSchema.parse(data);
+}
+function createInitialState() {
+  return {
+    version: "1.0.0",
+    activeDomain: null,
+    activeSession: null,
+    sessions: {}
+  };
+}
+
+// src/core/config.ts
+var ConfigManager = class {
+  globalConfig = null;
+  state = null;
+  domainCache = /* @__PURE__ */ new Map();
+  /**
+   * Load global configuration
+   */
+  loadGlobalConfig() {
+    if (this.globalConfig) {
+      return this.globalConfig;
+    }
+    const configPath = paths.globalConfigFile;
+    if (!existsSync(configPath)) {
+      this.globalConfig = {
+        version: "1.0.0",
+        defaultDomain: "default",
+        autoArchive: true,
+        logLevel: "info"
+      };
+      this.saveGlobalConfig(this.globalConfig);
+      return this.globalConfig;
+    }
+    try {
+      const content = readFileSync(configPath, "utf-8");
+      const data = parse(content);
+      this.globalConfig = GlobalConfigSchema.parse(data);
+      return this.globalConfig;
+    } catch (error) {
+      throw new Error(`Failed to load global config: ${error}`);
+    }
+  }
+  /**
+   * Save global configuration
+   */
+  saveGlobalConfig(config) {
+    const configPath = paths.globalConfigFile;
+    const content = stringify(config, { indent: 2 });
+    writeFileSync(configPath, content, "utf-8");
+    this.globalConfig = config;
+  }
+  /**
+   * Load state file
+   */
+  loadState() {
+    if (this.state) {
+      return this.state;
+    }
+    const statePath = paths.stateFile;
+    if (!existsSync(statePath)) {
+      this.state = createInitialState();
+      this.saveState(this.state);
+      return this.state;
+    }
+    try {
+      const content = readFileSync(statePath, "utf-8");
+      const data = JSON.parse(content);
+      this.state = validateState(data);
+      return this.state;
+    } catch (error) {
+      throw new Error(`Failed to load state: ${error}`);
+    }
+  }
+  /**
+   * Save state file (atomic write)
+   */
+  saveState(state) {
+    const statePath = paths.stateFile;
+    const tempPath = `${statePath}.tmp`;
+    const content = JSON.stringify(state, null, 2);
+    writeFileSync(tempPath, content, "utf-8");
+    renameSync(tempPath, statePath);
+    this.state = state;
+  }
+  /**
+   * Load a domain configuration
+   */
+  loadDomain(domainName) {
+    if (this.domainCache.has(domainName)) {
+      return this.domainCache.get(domainName);
+    }
+    const domainPath = paths.domainConfigFile(domainName);
+    if (!existsSync(domainPath)) {
+      throw new Error(`Domain '${domainName}' not found`);
+    }
+    try {
+      const content = readFileSync(domainPath, "utf-8");
+      const data = parse(content);
+      let domain = validateDomain(data);
+      if (domain.extends) {
+        const parent = this.loadDomain(domain.extends);
+        domain = this.mergeDomains(parent, domain);
+      }
+      domain.workingDirectory = paths.expandPath(domain.workingDirectory);
+      if (domain.claudeConfig?.instructions) {
+        domain.claudeConfig.instructions = paths.expandPath(domain.claudeConfig.instructions);
+      }
+      if (domain.claudeConfig?.memory) {
+        domain.claudeConfig.memory = domain.claudeConfig.memory.map((p) => paths.expandPath(p));
+      }
+      this.domainCache.set(domainName, domain);
+      return domain;
+    } catch (error) {
+      throw new Error(`Failed to load domain '${domainName}': ${error}`);
+    }
+  }
+  /**
+   * Save a domain configuration
+   */
+  saveDomain(domain) {
+    const domainPath = paths.domainConfigFile(domain.name);
+    const content = stringify(domain, { indent: 2 });
+    writeFileSync(domainPath, content, "utf-8");
+    this.domainCache.set(domain.name, domain);
+  }
+  /**
+   * Create a new domain from template
+   */
+  createDomain(name, template) {
+    const domain = {
+      ...DEFAULT_DOMAIN_TEMPLATE,
+      ...template,
+      name,
+      metadata: {
+        ...DEFAULT_DOMAIN_TEMPLATE.metadata,
+        ...template?.metadata,
+        created: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+    this.saveDomain(domain);
+    return domain;
+  }
+  /**
+   * List all available domains
+   */
+  listDomains() {
+    const domainsDir = paths.domainsDir;
+    if (!existsSync(domainsDir)) {
+      return [];
+    }
+    return readdirSync(domainsDir).filter((file) => file.endsWith(".yml")).map((file) => file.replace(".yml", ""));
+  }
+  /**
+   * Check if a domain exists
+   */
+  domainExists(domainName) {
+    const domainPath = paths.domainConfigFile(domainName);
+    return existsSync(domainPath);
+  }
+  /**
+   * Delete a domain
+   */
+  deleteDomain(domainName) {
+    const domainPath = paths.domainConfigFile(domainName);
+    if (!existsSync(domainPath)) {
+      throw new Error(`Domain '${domainName}' not found`);
+    }
+    unlinkSync(domainPath);
+    this.domainCache.delete(domainName);
+  }
+  /**
+   * Merge two domain configurations (child overrides parent)
+   */
+  mergeDomains(parent, child) {
+    const merged = {
+      ...parent,
+      ...child,
+      name: child.name || parent.name,
+      workingDirectory: child.workingDirectory || parent.workingDirectory
+    };
+    if (parent.claudeConfig || child.claudeConfig) {
+      merged.claudeConfig = {
+        ...parent.claudeConfig,
+        ...child.claudeConfig
+      };
+      if (parent.claudeConfig?.memory || child.claudeConfig?.memory) {
+        merged.claudeConfig.memory = [
+          ...parent.claudeConfig?.memory || [],
+          ...child.claudeConfig?.memory || []
+        ];
+      }
+    }
+    if (parent.mcpServers || child.mcpServers) {
+      merged.mcpServers = {
+        ...parent.mcpServers,
+        ...child.mcpServers
+      };
+    }
+    if (parent.env || child.env) {
+      merged.env = {
+        ...parent.env,
+        ...child.env
+      };
+    }
+    if (parent.metadata || child.metadata) {
+      merged.metadata = {
+        ...parent.metadata,
+        ...child.metadata
+      };
+    }
+    return merged;
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.globalConfig = null;
+    this.state = null;
+    this.domainCache.clear();
+  }
+};
+var configManager = new ConfigManager();
+
+export {
+  configManager
+};