@vimukthid/ccsl 1.0.0

package/dist/index.cjs

@@ -0,0 +1,707 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  StatusInputSchema: () => StatusInputSchema,
+  availableWidgets: () => availableWidgets,
+  defaultConfig: () => defaultConfig,
+  formatStatusLine: () => formatStatusLine,
+  getClaudeSettingsPath: () => getClaudeSettingsPath,
+  installToClaudeSettings: () => installToClaudeSettings,
+  isInstalledInClaude: () => isInstalledInClaude,
+  loadConfig: () => loadConfig,
+  parseStatusInput: () => parseStatusInput,
+  sampleStatusInput: () => sampleStatusInput,
+  themeNames: () => themeNames,
+  themes: () => themes,
+  uninstallFromClaudeSettings: () => uninstallFromClaudeSettings
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/themes/index.ts
+var neonTheme = {
+  name: "neon",
+  colors: {
+    model: { fg: "#00ffff", bold: true },
+    context: { fg: "#ff00ff" },
+    contextHigh: { fg: "#ffff00" },
+    contextCritical: { fg: "#ff0000", bold: true },
+    tokens: { fg: "#00ff00" },
+    cost: { fg: "#ffff00" },
+    duration: { fg: "#00aaff" },
+    lines: { fg: "#ff6600" },
+    linesAdded: { fg: "#00ff00" },
+    linesRemoved: { fg: "#ff0066" },
+    directory: { fg: "#00ffff" },
+    version: { fg: "#aaaaff" },
+    separator: { fg: "#666666" }
+  }
+};
+var rainbowTheme = {
+  name: "rainbow",
+  colors: {
+    model: { fg: "#ff0000", bold: true },
+    context: { fg: "#ff7f00" },
+    contextHigh: { fg: "#ffff00" },
+    contextCritical: { fg: "#ff0000", bold: true },
+    tokens: { fg: "#00ff00" },
+    cost: { fg: "#0000ff" },
+    duration: { fg: "#4b0082" },
+    lines: { fg: "#9400d3" },
+    linesAdded: { fg: "#00ff00" },
+    linesRemoved: { fg: "#ff0000" },
+    directory: { fg: "#ff7f00" },
+    version: { fg: "#9400d3" },
+    separator: { fg: "#888888" }
+  }
+};
+var oceanTheme = {
+  name: "ocean",
+  colors: {
+    model: { fg: "#00bcd4", bold: true },
+    context: { fg: "#2d8b8b" },
+    contextHigh: { fg: "#4dd0e1" },
+    contextCritical: { fg: "#ff5252", bold: true },
+    tokens: { fg: "#80deea" },
+    cost: { fg: "#4dd0e1" },
+    duration: { fg: "#0288d1" },
+    lines: { fg: "#26c6da" },
+    linesAdded: { fg: "#69f0ae" },
+    linesRemoved: { fg: "#ff5252" },
+    directory: { fg: "#00bcd4" },
+    version: { fg: "#80deea" },
+    separator: { fg: "#37474f" }
+  }
+};
+var minimalTheme = {
+  name: "minimal",
+  colors: {
+    model: { fg: "#888888" },
+    context: { fg: "#ffffff" },
+    contextHigh: { fg: "#e5c07b" },
+    contextCritical: { fg: "#e06c75", bold: true },
+    tokens: { fg: "#666666", dim: true },
+    cost: { fg: "#61afef" },
+    duration: { fg: "#666666", dim: true },
+    lines: { fg: "#abb2bf" },
+    linesAdded: { fg: "#98c379" },
+    linesRemoved: { fg: "#e06c75" },
+    directory: { fg: "#888888" },
+    version: { fg: "#5c6370" },
+    separator: { fg: "#444444" }
+  },
+  icons: {
+    model: "",
+    context: "",
+    tokens: "",
+    duration: "",
+    lines: "",
+    directory: ""
+  }
+};
+var monochromeTheme = {
+  name: "monochrome",
+  colors: {
+    model: { fg: "#ffffff", bold: true },
+    context: { fg: "#cccccc" },
+    contextHigh: { fg: "#ffffff", bold: true },
+    contextCritical: { fg: "#ffffff", bold: true, underline: true },
+    tokens: { fg: "#aaaaaa" },
+    cost: { fg: "#999999" },
+    duration: { fg: "#888888" },
+    lines: { fg: "#777777" },
+    linesAdded: { fg: "#cccccc" },
+    linesRemoved: { fg: "#888888" },
+    directory: { fg: "#aaaaaa" },
+    version: { fg: "#666666" },
+    separator: { fg: "#444444" }
+  },
+  icons: {
+    model: "",
+    context: "",
+    tokens: "",
+    duration: "",
+    lines: "",
+    directory: ""
+  }
+};
+var corporateTheme = {
+  name: "corporate",
+  colors: {
+    model: { fg: "#3b82f6", bold: true },
+    context: { fg: "#64748b" },
+    contextHigh: { fg: "#f59e0b" },
+    contextCritical: { fg: "#ef4444", bold: true },
+    tokens: { fg: "#4682b4" },
+    cost: { fg: "#6b7280" },
+    duration: { fg: "#64748b" },
+    lines: { fg: "#94a3b8" },
+    linesAdded: { fg: "#22c55e" },
+    linesRemoved: { fg: "#ef4444" },
+    directory: { fg: "#3b82f6" },
+    version: { fg: "#94a3b8" },
+    separator: { fg: "#334155" }
+  }
+};
+var themes = {
+  neon: neonTheme,
+  rainbow: rainbowTheme,
+  ocean: oceanTheme,
+  minimal: minimalTheme,
+  monochrome: monochromeTheme,
+  corporate: corporateTheme
+};
+var themeNames = Object.keys(themes);
+
+// src/utils/icons.ts
+var nerdIcons = {
+  model: "\u25C8",
+  context: "\u25D0",
+  tokens: "\u{F0284}",
+  cost: "$",
+  duration: "\u23F1",
+  lines: "\xB1",
+  directory: "",
+  version: ""
+};
+var unicodeIcons = {
+  model: "\u25C8",
+  context: "\u25D0",
+  tokens: "\u21C5",
+  cost: "$",
+  duration: "\u23F1",
+  lines: "\xB1",
+  directory: "\u{1F4C1}",
+  version: "v"
+};
+var asciiIcons = {
+  model: "*",
+  context: "%",
+  tokens: "",
+  cost: "$",
+  duration: "",
+  lines: "",
+  directory: "",
+  version: "v"
+};
+var detectedIconMode = null;
+function detectIconSupport() {
+  if (detectedIconMode !== null) {
+    return detectedIconMode;
+  }
+  const term = process.env.TERM || "";
+  const termProgram = process.env.TERM_PROGRAM || "";
+  const nerdFontEnv = process.env.NERD_FONT || "";
+  if (nerdFontEnv === "1" || nerdFontEnv.toLowerCase() === "true") {
+    detectedIconMode = "nerd";
+    return "nerd";
+  }
+  const nerdFontTerminals = ["iTerm.app", "WezTerm", "Alacritty", "kitty", "Hyper", "Tabby"];
+  if (nerdFontTerminals.some((t) => termProgram.includes(t))) {
+    detectedIconMode = "nerd";
+    return "nerd";
+  }
+  if (term.includes("256color") || term.includes("truecolor")) {
+    detectedIconMode = "unicode";
+    return "unicode";
+  }
+  detectedIconMode = "ascii";
+  return "ascii";
+}
+function getIcon(key, theme, mode) {
+  if (theme.icons && theme.icons[key]) {
+    return theme.icons[key] || "";
+  }
+  const effectiveMode = mode === "auto" ? detectIconSupport() : mode;
+  switch (effectiveMode) {
+    case "nerd":
+      return nerdIcons[key] || "";
+    case "unicode":
+      return unicodeIcons[key] || "";
+    case "ascii":
+      return asciiIcons[key] || "";
+    default:
+      return unicodeIcons[key] || "";
+  }
+}
+
+// src/utils/colors.ts
+var import_chalk = __toESM(require("chalk"), 1);
+function applyStyle(text, style) {
+  if (!style) return text;
+  let result = import_chalk.default;
+  if (style.fg) {
+    result = result.hex(style.fg);
+  }
+  if (style.bg) {
+    result = result.bgHex(style.bg);
+  }
+  if (style.bold) {
+    result = result.bold;
+  }
+  if (style.dim) {
+    result = result.dim;
+  }
+  if (style.italic) {
+    result = result.italic;
+  }
+  if (style.underline) {
+    result = result.underline;
+  }
+  return result(text);
+}
+
+// src/utils/format.ts
+function formatNumber(num) {
+  if (num >= 1e6) {
+    return `${(num / 1e6).toFixed(1)}m`;
+  }
+  if (num >= 1e3) {
+    return `${(num / 1e3).toFixed(1)}k`;
+  }
+  return num.toString();
+}
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    const remainingSeconds = seconds % 60;
+    return remainingSeconds > 0 ? `${minutes}m${remainingSeconds}s` : `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return remainingMinutes > 0 ? `${hours}h${remainingMinutes}m` : `${hours}h`;
+}
+function formatCost(usd) {
+  if (usd < 0.01) {
+    return usd.toFixed(4);
+  }
+  if (usd < 1) {
+    return usd.toFixed(2);
+  }
+  return usd.toFixed(2);
+}
+
+// src/widgets/index.ts
+var import_path = __toESM(require("path"), 1);
+var availableWidgets = [
+  "model",
+  "context",
+  "tokens",
+  "cost",
+  "duration",
+  "lines",
+  "directory",
+  "version"
+];
+function renderWidget(widget, input, theme, config) {
+  switch (widget) {
+    case "model":
+      return renderModel(input, theme, config);
+    case "context":
+      return renderContext(input, theme, config);
+    case "tokens":
+      return renderTokens(input, theme, config);
+    case "cost":
+      return renderCostWidget(input, theme, config);
+    case "duration":
+      return renderDurationWidget(input, theme, config);
+    case "lines":
+      return renderLines(input, theme, config);
+    case "directory":
+      return renderDirectory(input, theme, config);
+    case "version":
+      return renderVersion(input, theme, config);
+    default:
+      return { content: "", visible: false };
+  }
+}
+function renderModel(input, theme, config) {
+  const displayName = input.model?.display_name;
+  if (!displayName) {
+    return { content: "", visible: false };
+  }
+  const icon = getIcon("model", theme, config.icons);
+  const text = icon ? `${icon} ${displayName}` : displayName;
+  const content = applyStyle(text, theme.colors.model);
+  return { content, visible: true };
+}
+function renderContext(input, theme, config) {
+  const percentage = input.context_window?.used_percentage;
+  if (percentage === void 0) {
+    return { content: "", visible: false };
+  }
+  const icon = getIcon("context", theme, config.icons);
+  const roundedPercent = Math.round(percentage);
+  const progressBar = renderProgressBar(percentage, theme);
+  const value = `${roundedPercent}%`;
+  const text = icon ? `${icon} ${progressBar} ${value}` : `${progressBar} ${value}`;
+  let colorKey = "context";
+  if (percentage >= 80) {
+    colorKey = "contextCritical";
+  } else if (percentage >= 60) {
+    colorKey = "contextHigh";
+  }
+  const style = theme.colors[colorKey] || theme.colors.context;
+  const content = applyStyle(text, style);
+  return { content, visible: true };
+}
+function renderProgressBar(percentage, theme) {
+  const totalBars = 10;
+  const filledBars = Math.round(percentage / 100 * totalBars);
+  const emptyBars = totalBars - filledBars;
+  const filledChar = "\u2588";
+  const emptyChar = "\u2591";
+  let filledStyle = theme.colors.context;
+  if (percentage >= 80) {
+    filledStyle = theme.colors.contextCritical || theme.colors.context;
+  } else if (percentage >= 60) {
+    filledStyle = theme.colors.contextHigh || theme.colors.context;
+  }
+  const filled = applyStyle(filledChar.repeat(filledBars), filledStyle);
+  const empty = applyStyle(emptyChar.repeat(emptyBars), { fg: "#444444", dim: true });
+  return `${filled}${empty}`;
+}
+function renderTokens(input, theme, config) {
+  const inputTokens = input.context_window?.total_input_tokens;
+  const outputTokens = input.context_window?.total_output_tokens;
+  if (inputTokens === void 0 && outputTokens === void 0) {
+    return { content: "", visible: false };
+  }
+  const icon = getIcon("tokens", theme, config.icons);
+  const inStr = formatNumber(inputTokens ?? 0);
+  const outStr = formatNumber(outputTokens ?? 0);
+  const text = icon ? `${icon} \u2191${inStr} \u2193${outStr}` : `\u2191${inStr} \u2193${outStr}`;
+  const content = applyStyle(text, theme.colors.tokens);
+  return { content, visible: true };
+}
+function renderCostWidget(input, theme, config) {
+  const costUsd = input.cost?.total_cost_usd;
+  if (costUsd === void 0) {
+    return { content: "", visible: false };
+  }
+  const icon = getIcon("cost", theme, config.icons);
+  const value = formatCost(costUsd);
+  const text = icon ? `${icon}${value}` : `$${value}`;
+  const content = applyStyle(text, theme.colors.cost);
+  return { content, visible: true };
+}
+function renderDurationWidget(input, theme, config) {
+  const durationMs = input.cost?.total_duration_ms;
+  if (durationMs === void 0) {
+    return { content: "", visible: false };
+  }
+  const icon = getIcon("duration", theme, config.icons);
+  const value = formatDuration(durationMs);
+  const text = icon ? `${icon} ${value}` : value;
+  const content = applyStyle(text, theme.colors.duration);
+  return { content, visible: true };
+}
+function renderLines(input, theme, config) {
+  const added = input.cost?.total_lines_added;
+  const removed = input.cost?.total_lines_removed;
+  if (added === void 0 && removed === void 0) {
+    return { content: "", visible: false };
+  }
+  const icon = getIcon("lines", theme, config.icons);
+  const addedStr = applyStyle(`+${added ?? 0}`, theme.colors.linesAdded || theme.colors.lines);
+  const removedStr = applyStyle(`-${removed ?? 0}`, theme.colors.linesRemoved || theme.colors.lines);
+  const text = icon ? `${icon} ${addedStr} ${removedStr}` : `${addedStr} ${removedStr}`;
+  return { content: text, visible: true };
+}
+function renderDirectory(input, theme, config) {
+  const dir = input.workspace?.current_dir || input.cwd;
+  if (!dir) {
+    return { content: "", visible: false };
+  }
+  const icon = getIcon("directory", theme, config.icons);
+  const dirName = import_path.default.basename(dir);
+  const text = icon ? `${icon} ${dirName}` : dirName;
+  const content = applyStyle(text, theme.colors.directory);
+  return { content, visible: true };
+}
+function renderVersion(input, theme, config) {
+  const version = input.version;
+  if (!version) {
+    return { content: "", visible: false };
+  }
+  const icon = getIcon("version", theme, config.icons);
+  const text = icon ? `${icon}${version}` : `v${version}`;
+  const content = applyStyle(text, theme.colors.version);
+  return { content, visible: true };
+}
+
+// src/formatter.ts
+function formatStatusLine(input, config) {
+  const theme = config.customTheme || themes[config.theme] || themes.minimal;
+  const renderedWidgets = [];
+  for (const widget of config.widgets) {
+    const result = renderWidget(widget, input, theme, config);
+    if (result.visible && result.content) {
+      renderedWidgets.push(result.content);
+    }
+  }
+  if (renderedWidgets.length === 0) {
+    return "";
+  }
+  const separator = applyStyle(config.separator, theme.colors.separator);
+  const statusLine = renderedWidgets.join(separator);
+  const padding = " ".repeat(config.padding);
+  return `\x1B[0m${padding}${statusLine}${padding}`;
+}
+var sampleStatusInput = {
+  hook_event_name: "Status",
+  session_id: "sample-session-123",
+  model: {
+    id: "claude-opus-4-1",
+    display_name: "Opus"
+  },
+  workspace: {
+    current_dir: "/home/user/my-project",
+    project_dir: "/home/user/my-project"
+  },
+  version: "1.0.80",
+  cost: {
+    total_cost_usd: 0.0234,
+    total_duration_ms: 45e3,
+    total_api_duration_ms: 2300,
+    total_lines_added: 156,
+    total_lines_removed: 23
+  },
+  context_window: {
+    total_input_tokens: 15234,
+    total_output_tokens: 4521,
+    context_window_size: 2e5,
+    used_percentage: 42.5,
+    remaining_percentage: 57.5,
+    current_usage: {
+      input_tokens: 8500,
+      output_tokens: 1200,
+      cache_creation_input_tokens: 5e3,
+      cache_read_input_tokens: 2e3
+    }
+  }
+};
+
+// src/parser.ts
+var import_zod = require("zod");
+var StatusInputSchema = import_zod.z.object({
+  hook_event_name: import_zod.z.string().optional(),
+  session_id: import_zod.z.string().optional(),
+  transcript_path: import_zod.z.string().optional(),
+  cwd: import_zod.z.string().optional(),
+  model: import_zod.z.object({
+    id: import_zod.z.string().optional(),
+    display_name: import_zod.z.string().optional()
+  }).optional(),
+  workspace: import_zod.z.object({
+    current_dir: import_zod.z.string().optional(),
+    project_dir: import_zod.z.string().optional()
+  }).optional(),
+  version: import_zod.z.string().optional(),
+  output_style: import_zod.z.object({
+    name: import_zod.z.string().optional()
+  }).optional(),
+  cost: import_zod.z.object({
+    total_cost_usd: import_zod.z.number().optional(),
+    total_duration_ms: import_zod.z.number().optional(),
+    total_api_duration_ms: import_zod.z.number().optional(),
+    total_lines_added: import_zod.z.number().optional(),
+    total_lines_removed: import_zod.z.number().optional()
+  }).optional(),
+  context_window: import_zod.z.object({
+    total_input_tokens: import_zod.z.number().optional(),
+    total_output_tokens: import_zod.z.number().optional(),
+    context_window_size: import_zod.z.number().optional(),
+    used_percentage: import_zod.z.number().optional(),
+    remaining_percentage: import_zod.z.number().optional(),
+    current_usage: import_zod.z.object({
+      input_tokens: import_zod.z.number().optional(),
+      output_tokens: import_zod.z.number().optional(),
+      cache_creation_input_tokens: import_zod.z.number().optional(),
+      cache_read_input_tokens: import_zod.z.number().optional()
+    }).nullable().optional()
+  }).optional()
+}).passthrough();
+function parseStatusInput(input) {
+  try {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      return null;
+    }
+    const parsed = JSON.parse(trimmed);
+    const result = StatusInputSchema.safeParse(parsed);
+    if (result.success) {
+      return result.data;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+// src/config/loader.ts
+var import_cosmiconfig = require("cosmiconfig");
+
+// src/config/defaults.ts
+var defaultWidgets = ["model", "context", "tokens", "cost"];
+var defaultConfig = {
+  theme: "minimal",
+  widgets: defaultWidgets,
+  separator: " \u2502 ",
+  icons: "auto",
+  padding: 1
+};
+
+// src/config/loader.ts
+var explorer = (0, import_cosmiconfig.cosmiconfig)("ccsl", {
+  searchPlaces: [
+    ".ccslrc",
+    ".ccslrc.json",
+    ".ccslrc.yaml",
+    ".ccslrc.yml",
+    ".ccslrc.js",
+    ".ccslrc.cjs",
+    ".config/ccsl/config.json",
+    "ccsl.config.js",
+    "ccsl.config.cjs"
+  ]
+});
+async function loadConfig(searchFrom) {
+  try {
+    const result = await explorer.search(searchFrom);
+    if (result && result.config) {
+      return mergeConfig(defaultConfig, result.config);
+    }
+  } catch {
+  }
+  return { ...defaultConfig };
+}
+function mergeConfig(defaults, userConfig) {
+  return {
+    theme: userConfig.theme ?? defaults.theme,
+    widgets: userConfig.widgets ?? defaults.widgets,
+    separator: userConfig.separator ?? defaults.separator,
+    icons: userConfig.icons ?? defaults.icons,
+    padding: userConfig.padding ?? defaults.padding,
+    customTheme: userConfig.customTheme
+  };
+}
+
+// src/config/claude.ts
+var import_fs = require("fs");
+var import_path2 = require("path");
+var import_os = require("os");
+function getClaudeSettingsPath() {
+  const claudeDir = process.env.CLAUDE_CONFIG_DIR || (0, import_path2.join)((0, import_os.homedir)(), ".claude");
+  return (0, import_path2.join)(claudeDir, "settings.json");
+}
+function getClaudeSettings() {
+  const settingsPath = getClaudeSettingsPath();
+  if (!(0, import_fs.existsSync)(settingsPath)) {
+    return null;
+  }
+  try {
+    const content = (0, import_fs.readFileSync)(settingsPath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function installToClaudeSettings(command = "npx @vimukthid/ccsl") {
+  const settingsPath = getClaudeSettingsPath();
+  const dir = (0, import_path2.dirname)(settingsPath);
+  if (!(0, import_fs.existsSync)(dir)) {
+    (0, import_fs.mkdirSync)(dir, { recursive: true });
+  }
+  let settings = {};
+  if ((0, import_fs.existsSync)(settingsPath)) {
+    try {
+      const content = (0, import_fs.readFileSync)(settingsPath, "utf8");
+      settings = JSON.parse(content);
+    } catch {
+      settings = {};
+    }
+  }
+  settings.statusLine = {
+    type: "command",
+    command
+  };
+  try {
+    (0, import_fs.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function uninstallFromClaudeSettings() {
+  const settingsPath = getClaudeSettingsPath();
+  if (!(0, import_fs.existsSync)(settingsPath)) {
+    return true;
+  }
+  try {
+    const content = (0, import_fs.readFileSync)(settingsPath, "utf8");
+    const settings = JSON.parse(content);
+    delete settings.statusLine;
+    (0, import_fs.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isInstalledInClaude() {
+  const settings = getClaudeSettings();
+  if (!settings?.statusLine) {
+    return false;
+  }
+  const command = settings.statusLine.command || "";
+  return command.includes("ccsl") || command.includes("@vimukthid/ccsl");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StatusInputSchema,
+  availableWidgets,
+  defaultConfig,
+  formatStatusLine,
+  getClaudeSettingsPath,
+  installToClaudeSettings,
+  isInstalledInClaude,
+  loadConfig,
+  parseStatusInput,
+  sampleStatusInput,
+  themeNames,
+  themes,
+  uninstallFromClaudeSettings
+});
+//# sourceMappingURL=index.cjs.map