@leynier/ccst 0.1.0

package/src/index.ts

@@ -0,0 +1,148 @@
+import { Command } from "commander";
+import { getPaths } from "./utils/paths.js";
+import { ContextManager } from "./core/context-manager.js";
+import { resolveSettingsLevel } from "./core/settings-level.js";
+import { listCommand } from "./commands/list.js";
+import { switchCommand, switchPreviousCommand } from "./commands/switch.js";
+import { createCommand } from "./commands/create.js";
+import { deleteCommand } from "./commands/delete.js";
+import { renameCommand } from "./commands/rename.js";
+import { editCommand } from "./commands/edit.js";
+import { showCommand } from "./commands/show.js";
+import { exportCommand } from "./commands/export.js";
+import { importCommand } from "./commands/import.js";
+import { unsetCommand } from "./commands/unset.js";
+import { mergeCommand, mergeHistoryCommand, unmergeCommand } from "./commands/merge.js";
+import { completionsCommand } from "./commands/completions.js";
+import { importFromCcs } from "./commands/import-profiles/ccs.js";
+import { importFromConfigs } from "./commands/import-profiles/configs.js";
+
+export const program = new Command();
+
+const main = async (): Promise<void> => {
+  program
+    .name("ccst")
+    .description("Claude Code Switch Tools")
+    .argument("[context]", "context name")
+    .option("-d, --delete", "delete context")
+    .option("-c, --current", "print current context")
+    .option("-r, --rename", "rename context")
+    .option("-n, --new", "create new context")
+    .option("-e, --edit", "edit context")
+    .option("-s, --show", "show context")
+    .option("--export", "export context to stdout")
+    .option("--import", "import context from stdin")
+    .option("-u, --unset", "unset current context")
+    .option("--completions <shell>", "generate completions")
+    .option("-q, --quiet", "show only current context")
+    .option("--in-project", "use project settings level")
+    .option("--local", "use local settings level")
+    .option("--merge-from <source>", "merge permissions from source")
+    .option("--unmerge <source>", "remove permissions merged from source")
+    .option("--merge-history", "show merge history")
+    .option("--merge-full", "merge full settings")
+    .allowExcessArguments(false);
+  const importCommandGroup = program.command("import").description("import profiles");
+  importCommandGroup
+    .command("ccs")
+    .description("import from CCS settings")
+    .option("-d, --configs-dir <dir>", "configs directory")
+    .action(async (options) => {
+      const manager = new ContextManager(getPaths("user"));
+      await importFromCcs(manager, options.configsDir);
+    });
+  importCommandGroup
+    .command("configs")
+    .description("import from configs directory")
+    .option("-d, --configs-dir <dir>", "configs directory")
+    .action(async (options) => {
+      const manager = new ContextManager(getPaths("user"));
+      await importFromConfigs(manager, options.configsDir);
+    });
+  try {
+    await program.parseAsync(process.argv);
+  } catch {
+    return;
+  }
+  const options = program.opts();
+  const [context] = program.args as [string | undefined];
+  if (context === "import") {
+    return;
+  }
+  if (options.completions) {
+    completionsCommand(options.completions);
+    return;
+  }
+  const level = resolveSettingsLevel(options);
+  const manager = new ContextManager(getPaths(level));
+  if (options.current) {
+    const current = await manager.getCurrentContext();
+    if (current) {
+      console.log(current);
+    }
+    return;
+  }
+  if (options.unset) {
+    await unsetCommand(manager);
+    return;
+  }
+  if (options.delete) {
+    await deleteCommand(manager, context);
+    return;
+  }
+  if (options.rename) {
+    await renameCommand(manager, context);
+    return;
+  }
+  if (options.new) {
+    if (!context) {
+      await manager.interactiveCreateContext();
+      return;
+    }
+    await createCommand(manager, context);
+    return;
+  }
+  if (options.edit) {
+    await editCommand(manager, context);
+    return;
+  }
+  if (options.show) {
+    await showCommand(manager, context);
+    return;
+  }
+  if (options.export) {
+    await exportCommand(manager, context);
+    return;
+  }
+  if (options.import) {
+    await importCommand(manager, context);
+    return;
+  }
+  if (options.mergeFrom) {
+    await mergeCommand(manager, options.mergeFrom, context, options.mergeFull);
+    return;
+  }
+  if (options.unmerge) {
+    await unmergeCommand(manager, options.unmerge, context, options.mergeFull);
+    return;
+  }
+  if (options.mergeHistory) {
+    await mergeHistoryCommand(manager, context);
+    return;
+  }
+  if (context === "-") {
+    await switchPreviousCommand(manager);
+    return;
+  }
+  if (context) {
+    await switchCommand(manager, context);
+    return;
+  }
+  if (process.env.CCTX_INTERACTIVE === "1") {
+    await manager.interactiveSelect();
+    return;
+  }
+  await listCommand(manager, options.quiet);
+};
+
+await main();

package/src/types/index.ts

@@ -0,0 +1,14 @@
+export type SettingsLevel = "user" | "project" | "local";
+
+export type State = {
+  current?: string;
+  previous?: string;
+};
+
+export type MergeHistoryEntry = {
+  source: string;
+  mergedItems: string[];
+  timestamp: string;
+};
+
+export type MergeHistory = MergeHistoryEntry[];

package/src/utils/colors.ts

@@ -0,0 +1,10 @@
+import pc from "picocolors";
+
+export const colors = {
+  green: pc.green,
+  red: pc.red,
+  cyan: pc.cyan,
+  yellow: pc.yellow,
+  bold: pc.bold,
+  dim: pc.dim,
+};

package/src/utils/deep-merge.ts

@@ -0,0 +1,22 @@
+export const deepMerge = (base: Record<string, unknown>, override: Record<string, unknown>): Record<string, unknown> => {
+  const result: Record<string, unknown> = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const baseValue = result[key];
+    if (isPlainObject(baseValue) && isPlainObject(value)) {
+      result[key] = deepMerge(baseValue, value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+};
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  return Object.getPrototypeOf(value) === Object.prototype;
+};

package/src/utils/interactive.ts

@@ -0,0 +1,69 @@
+import { spawnSync } from "node:child_process";
+
+const hasFzf = (): boolean => {
+  const which = spawnSync("which", ["fzf"], { stdio: "ignore" });
+  return which.status === 0 && Boolean(process.env.TERM);
+};
+
+export const selectContext = async (contexts: string[], current?: string): Promise<string | undefined> => {
+  if (contexts.length === 0) {
+    return undefined;
+  }
+  if (hasFzf()) {
+    const input = contexts.join("\n");
+    const result = spawnSync("fzf", [], { input, encoding: "utf8", stdio: ["pipe", "pipe", "inherit"] });
+    if (result.status !== 0) {
+      return undefined;
+    }
+    const selected = String(result.stdout).trim();
+    return selected.length > 0 ? selected : undefined;
+  }
+  return promptSelect(contexts, current);
+};
+
+const promptSelect = async (contexts: string[], current?: string): Promise<string | undefined> => {
+  const lines = contexts.map((ctx, index) => {
+    const marker = current && ctx === current ? " (current)" : "";
+    return `${index + 1}. ${ctx}${marker}`;
+  });
+  process.stdout.write(`${lines.join("\n")}\nSelect a context (number): `);
+  const input = await readStdinLine();
+  const index = Number.parseInt(input, 10);
+  if (!Number.isFinite(index) || index < 1 || index > contexts.length) {
+    return undefined;
+  }
+  return contexts[index - 1];
+};
+
+export const promptInput = async (label: string): Promise<string | undefined> => {
+  process.stdout.write(`${label}: `);
+  const input = await readStdinLine();
+  const trimmed = input.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+};
+
+const readStdinLine = async (): Promise<string> => {
+  return new Promise((resolve) => {
+    const chunks: Buffer[] = [];
+    const onData = (chunk: Buffer) => {
+      chunks.push(chunk);
+      if (chunk.includes(10)) {
+        cleanup();
+        resolve(Buffer.concat(chunks).toString("utf8").trim());
+      }
+    };
+    const onEnd = () => {
+      cleanup();
+      resolve(Buffer.concat(chunks).toString("utf8").trim());
+    };
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      process.stdin.off("end", onEnd);
+    };
+    if (process.stdin.isTTY) {
+      process.stdin.resume();
+    }
+    process.stdin.on("data", onData);
+    process.stdin.on("end", onEnd);
+  });
+};

package/src/utils/json.ts

@@ -0,0 +1,19 @@
+import { existsSync } from "node:fs";
+
+export const readJson = async <T>(filePath: string): Promise<T> => {
+  const text = await Bun.file(filePath).text();
+  return JSON.parse(text) as T;
+};
+
+export const readJsonIfExists = async <T>(filePath: string, fallback: T): Promise<T> => {
+  if (!existsSync(filePath)) {
+    return fallback;
+  }
+  const text = await Bun.file(filePath).text();
+  return JSON.parse(text) as T;
+};
+
+export const writeJson = async (filePath: string, value: unknown): Promise<void> => {
+  const payload = `${JSON.stringify(value, null, 2)}\n`;
+  await Bun.write(filePath, payload);
+};

package/src/utils/paths.ts

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { homedir } from "node:os";
+import { existsSync, readdirSync } from "node:fs";
+import type { SettingsLevel } from "../types/index.js";
+
+export type Paths = {
+  contextsDir: string;
+  settingsPath: string;
+  statePath: string;
+  settingsLevel: SettingsLevel;
+};
+
+export const getPaths = (level: SettingsLevel): Paths => {
+  const homeDir = homedir();
+  const currentDir = process.cwd();
+  if (level === "user") {
+    const claudeDir = path.join(homeDir, ".claude");
+    const contextsDir = path.join(claudeDir, "settings");
+    return {
+      contextsDir,
+      settingsPath: path.join(claudeDir, "settings.json"),
+      statePath: path.join(contextsDir, ".cctx-state.json"),
+      settingsLevel: level,
+    };
+  }
+  if (level === "project") {
+    const claudeDir = path.join(currentDir, ".claude");
+    const contextsDir = path.join(claudeDir, "settings");
+    return {
+      contextsDir,
+      settingsPath: path.join(claudeDir, "settings.json"),
+      statePath: path.join(contextsDir, ".cctx-state.json"),
+      settingsLevel: level,
+    };
+  }
+  const claudeDir = path.join(currentDir, ".claude");
+  const contextsDir = path.join(claudeDir, "settings");
+  return {
+    contextsDir,
+    settingsPath: path.join(claudeDir, "settings.local.json"),
+    statePath: path.join(contextsDir, ".cctx-state.local.json"),
+    settingsLevel: level,
+  };
+};
+
+export const hasProjectContexts = (): boolean => {
+  const contextsDir = path.join(process.cwd(), ".claude", "settings");
+  try {
+    const entries = readdirSync(contextsDir);
+    return entries.some((name) => name.endsWith(".json") && !name.startsWith("."));
+  } catch {
+    return false;
+  }
+};
+
+export const hasLocalContexts = (): boolean => {
+  return existsSync(path.join(process.cwd(), ".claude", "settings.local.json"));
+};

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+	"compilerOptions": {
+		// Environment setup & latest features
+		"lib": ["ESNext"],
+		"target": "ESNext",
+		"module": "Preserve",
+		"moduleDetection": "force",
+		"jsx": "react-jsx",
+		"allowJs": true,
+
+		// Bundler mode
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"noEmit": true,
+
+		// Best practices
+		"strict": true,
+		"skipLibCheck": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedIndexedAccess": true,
+		"noImplicitOverride": true,
+
+		// Some stricter flags (disabled by default)
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"noPropertyAccessFromIndexSignature": false
+	}
+}