@vimukthid/ccsl 1.0.0

package/dist/cli.js

@@ -0,0 +1,1225 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/config/defaults.ts
+var defaultWidgets, defaultConfig;
+var init_defaults = __esm({
+  "src/config/defaults.ts"() {
+    "use strict";
+    init_esm_shims();
+    defaultWidgets = ["model", "context", "tokens", "cost"];
+    defaultConfig = {
+      theme: "minimal",
+      widgets: defaultWidgets,
+      separator: " \u2502 ",
+      icons: "auto",
+      padding: 1
+    };
+  }
+});
+
+// src/config/loader.ts
+import { cosmiconfig } from "cosmiconfig";
+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
+  };
+}
+function getConfigPath(scope) {
+  if (scope === "local") {
+    return ".ccslrc.json";
+  }
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  return `${home}/.config/ccsl/config.json`;
+}
+var explorer;
+var init_loader = __esm({
+  "src/config/loader.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_defaults();
+    explorer = cosmiconfig("ccsl", {
+      searchPlaces: [
+        ".ccslrc",
+        ".ccslrc.json",
+        ".ccslrc.yaml",
+        ".ccslrc.yml",
+        ".ccslrc.js",
+        ".ccslrc.cjs",
+        ".config/ccsl/config.json",
+        "ccsl.config.js",
+        "ccsl.config.cjs"
+      ]
+    });
+  }
+});
+
+// src/themes/index.ts
+var neonTheme, rainbowTheme, oceanTheme, minimalTheme, monochromeTheme, corporateTheme, themes, themeNames;
+var init_themes = __esm({
+  "src/themes/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    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" }
+      }
+    };
+    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" }
+      }
+    };
+    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" }
+      }
+    };
+    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: ""
+      }
+    };
+    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: ""
+      }
+    };
+    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" }
+      }
+    };
+    themes = {
+      neon: neonTheme,
+      rainbow: rainbowTheme,
+      ocean: oceanTheme,
+      minimal: minimalTheme,
+      monochrome: monochromeTheme,
+      corporate: corporateTheme
+    };
+    themeNames = Object.keys(themes);
+  }
+});
+
+// src/utils/icons.ts
+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] || "";
+  }
+}
+var nerdIcons, unicodeIcons, asciiIcons, detectedIconMode;
+var init_icons = __esm({
+  "src/utils/icons.ts"() {
+    "use strict";
+    init_esm_shims();
+    nerdIcons = {
+      model: "\u25C8",
+      context: "\u25D0",
+      tokens: "\u{F0284}",
+      cost: "$",
+      duration: "\u23F1",
+      lines: "\xB1",
+      directory: "",
+      version: ""
+    };
+    unicodeIcons = {
+      model: "\u25C8",
+      context: "\u25D0",
+      tokens: "\u21C5",
+      cost: "$",
+      duration: "\u23F1",
+      lines: "\xB1",
+      directory: "\u{1F4C1}",
+      version: "v"
+    };
+    asciiIcons = {
+      model: "*",
+      context: "%",
+      tokens: "",
+      cost: "$",
+      duration: "",
+      lines: "",
+      directory: "",
+      version: "v"
+    };
+    detectedIconMode = null;
+  }
+});
+
+// src/utils/colors.ts
+import chalk from "chalk";
+function applyStyle(text, style) {
+  if (!style) return text;
+  let result = chalk;
+  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);
+}
+var init_colors = __esm({
+  "src/utils/colors.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// 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);
+}
+var init_format = __esm({
+  "src/utils/format.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/widgets/index.ts
+import path2 from "path";
+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 = path2.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 };
+}
+var availableWidgets;
+var init_widgets = __esm({
+  "src/widgets/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_icons();
+    init_colors();
+    init_format();
+    availableWidgets = [
+      "model",
+      "context",
+      "tokens",
+      "cost",
+      "duration",
+      "lines",
+      "directory",
+      "version"
+    ];
+  }
+});
+
+// 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;
+var init_formatter = __esm({
+  "src/formatter.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_themes();
+    init_widgets();
+    init_colors();
+    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/config/claude.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+function getClaudeSettingsPath() {
+  const claudeDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+  return join(claudeDir, "settings.json");
+}
+function getClaudeSettings() {
+  const settingsPath = getClaudeSettingsPath();
+  if (!existsSync(settingsPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(settingsPath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function backupClaudeSettings() {
+  const settingsPath = getClaudeSettingsPath();
+  if (!existsSync(settingsPath)) {
+    return null;
+  }
+  const backupPath = settingsPath + ".backup";
+  try {
+    copyFileSync(settingsPath, backupPath);
+    return backupPath;
+  } catch {
+    return null;
+  }
+}
+function installToClaudeSettings(command = "npx @vimukthid/ccsl") {
+  const settingsPath = getClaudeSettingsPath();
+  const dir = dirname(settingsPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try {
+      const content = readFileSync(settingsPath, "utf8");
+      settings = JSON.parse(content);
+    } catch {
+      settings = {};
+    }
+  }
+  settings.statusLine = {
+    type: "command",
+    command
+  };
+  try {
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function uninstallFromClaudeSettings() {
+  const settingsPath = getClaudeSettingsPath();
+  if (!existsSync(settingsPath)) {
+    return true;
+  }
+  try {
+    const content = readFileSync(settingsPath, "utf8");
+    const settings = JSON.parse(content);
+    delete settings.statusLine;
+    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");
+}
+function getCurrentClaudeCommand() {
+  const settings = getClaudeSettings();
+  return settings?.statusLine?.command || null;
+}
+var init_claude = __esm({
+  "src/config/claude.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/tui/app.tsx
+var app_exports = {};
+__export(app_exports, {
+  launchTui: () => launchTui
+});
+import { useState } from "react";
+import { render, Box, Text, useApp, useInput } from "ink";
+import SelectInput from "ink-select-input";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function App({ initialConfig, scope }) {
+  const { exit } = useApp();
+  const [screen, setScreen] = useState("main");
+  const [config, setConfig] = useState(initialConfig);
+  const [message, setMessage] = useState("");
+  useInput((input, key) => {
+    if (key.escape) {
+      if (screen === "main") {
+        exit();
+      } else {
+        setScreen("main");
+      }
+    }
+    if (input === "q" && screen === "main") {
+      exit();
+    }
+  });
+  const saveConfig = () => {
+    const configPath = getConfigPath(scope);
+    try {
+      const dir = dirname2(configPath);
+      if (!existsSync2(dir)) {
+        mkdirSync2(dir, { recursive: true });
+      }
+      writeFileSync2(configPath, JSON.stringify(config, null, 2));
+      setMessage("Configuration saved!");
+      setTimeout(() => setMessage(""), 2e3);
+    } catch (err) {
+      setMessage(`Error saving: ${err}`);
+    }
+  };
+  const renderMain = () => {
+    const items = [
+      { label: "Select Theme", value: "themes" },
+      { label: "Configure Widgets", value: "widgets" },
+      { label: "General Settings", value: "settings" },
+      { label: "Live Preview", value: "preview" },
+      { label: "Install to Claude Code", value: "install" },
+      { label: "Save Configuration", value: "save" },
+      { label: "Exit", value: "exit" }
+    ];
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "CCSL Configuration" }),
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          " (",
+          scope,
+          ")"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(
+        SelectInput,
+        {
+          items,
+          onSelect: (item) => {
+            if (item.value === "exit") {
+              exit();
+            } else if (item.value === "save") {
+              saveConfig();
+            } else {
+              setScreen(item.value);
+            }
+          }
+        }
+      ),
+      message && /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "green", children: message }) }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Press q or Esc to exit" }) })
+    ] });
+  };
+  const renderThemes = () => {
+    const items = themeNames.map((name) => ({
+      label: `${name}${config.theme === name ? " (current)" : ""}`,
+      value: name
+    }));
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "Select Theme" }) }),
+      /* @__PURE__ */ jsx(
+        SelectInput,
+        {
+          items,
+          onSelect: (item) => {
+            setConfig({ ...config, theme: item.value });
+            setScreen("main");
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx(Text, { color: "gray", children: "Preview:" }),
+        /* @__PURE__ */ jsx(Text, { children: formatStatusLine(sampleStatusInput, config) })
+      ] }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Press Esc to go back" }) })
+    ] });
+  };
+  const renderWidgets = () => {
+    const items = availableWidgets.map((widget) => ({
+      label: `${config.widgets.includes(widget) ? "[x]" : "[ ]"} ${widget}`,
+      value: widget
+    }));
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "Configure Widgets" }) }),
+      /* @__PURE__ */ jsx(
+        SelectInput,
+        {
+          items,
+          onSelect: (item) => {
+            const widget = item.value;
+            const newWidgets = config.widgets.includes(widget) ? config.widgets.filter((w) => w !== widget) : [...config.widgets, widget];
+            setConfig({ ...config, widgets: newWidgets });
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          "Current order: ",
+          config.widgets.join(", ")
+        ] }),
+        /* @__PURE__ */ jsx(Text, { children: formatStatusLine(sampleStatusInput, config) })
+      ] }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Press Esc to go back" }) })
+    ] });
+  };
+  const renderSettings = () => {
+    const iconOptions = [
+      { label: `Icons: auto${config.icons === "auto" ? " (current)" : ""}`, value: "icon-auto" },
+      { label: `Icons: nerd${config.icons === "nerd" ? " (current)" : ""}`, value: "icon-nerd" },
+      {
+        label: `Icons: unicode${config.icons === "unicode" ? " (current)" : ""}`,
+        value: "icon-unicode"
+      },
+      { label: `Icons: ascii${config.icons === "ascii" ? " (current)" : ""}`, value: "icon-ascii" }
+    ];
+    const separatorOptions = [
+      {
+        label: `Separator: " \u2502 "${config.separator === " \u2502 " ? " (current)" : ""}`,
+        value: "sep- \u2502 "
+      },
+      {
+        label: `Separator: " | "${config.separator === " | " ? " (current)" : ""}`,
+        value: "sep- | "
+      },
+      {
+        label: `Separator: " \xB7 "${config.separator === " \xB7 " ? " (current)" : ""}`,
+        value: "sep- \xB7 "
+      },
+      {
+        label: `Separator: "  "${config.separator === "  " ? " (current)" : ""}`,
+        value: "sep-  "
+      }
+    ];
+    const items = [...iconOptions, ...separatorOptions];
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "General Settings" }) }),
+      /* @__PURE__ */ jsx(
+        SelectInput,
+        {
+          items,
+          onSelect: (item) => {
+            if (item.value.startsWith("icon-")) {
+              const iconMode = item.value.replace("icon-", "");
+              setConfig({ ...config, icons: iconMode });
+            } else if (item.value.startsWith("sep-")) {
+              const sep = item.value.replace("sep-", "");
+              setConfig({ ...config, separator: sep });
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { children: formatStatusLine(sampleStatusInput, config) }) }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Press Esc to go back" }) })
+    ] });
+  };
+  const renderPreview = () => {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "Live Preview" }) }),
+      /* @__PURE__ */ jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          "Theme: ",
+          config.theme
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          "Widgets: ",
+          config.widgets.join(", ")
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          "Icons: ",
+          config.icons
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, children: "Output:" }) }),
+      /* @__PURE__ */ jsx(Text, { children: formatStatusLine(sampleStatusInput, config) }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 2, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Press Esc to go back" }) })
+    ] });
+  };
+  const renderInstall = () => {
+    const installed = isInstalledInClaude();
+    const currentCmd = getCurrentClaudeCommand();
+    const items = [
+      { label: installed ? "Update Installation" : "Install to Claude Code", value: "install" },
+      { label: "Back", value: "back" }
+    ];
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "Claude Code Integration" }) }),
+      /* @__PURE__ */ jsx(Box, { marginBottom: 1, flexDirection: "column", children: installed ? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "green", children: "Status: Installed" }),
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          "Command: ",
+          currentCmd
+        ] })
+      ] }) : /* @__PURE__ */ jsx(Text, { color: "yellow", children: "Status: Not installed" }) }),
+      /* @__PURE__ */ jsx(
+        SelectInput,
+        {
+          items,
+          onSelect: (item) => {
+            if (item.value === "install") {
+              const success = installToClaudeSettings();
+              if (success) {
+                setMessage("Installed! Restart Claude Code to apply.");
+              } else {
+                setMessage("Installation failed. Check permissions.");
+              }
+              setTimeout(() => setMessage(""), 3e3);
+            } else {
+              setScreen("main");
+            }
+          }
+        }
+      ),
+      message && /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: message.includes("failed") ? "red" : "green", children: message }) }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Press Esc to go back" }) })
+    ] });
+  };
+  return /* @__PURE__ */ jsxs(Box, { padding: 1, flexDirection: "column", children: [
+    screen === "main" && renderMain(),
+    screen === "themes" && renderThemes(),
+    screen === "widgets" && renderWidgets(),
+    screen === "settings" && renderSettings(),
+    screen === "preview" && renderPreview(),
+    screen === "install" && renderInstall()
+  ] });
+}
+async function launchTui(scope) {
+  const config = await loadConfig();
+  const { waitUntilExit } = render(/* @__PURE__ */ jsx(App, { initialConfig: config, scope }));
+  await waitUntilExit();
+}
+var init_app = __esm({
+  "src/tui/app.tsx"() {
+    "use strict";
+    init_esm_shims();
+    init_loader();
+    init_themes();
+    init_formatter();
+    init_widgets();
+    init_claude();
+  }
+});
+
+// src/cli.ts
+init_esm_shims();
+init_loader();
+import { Command } from "commander";
+
+// src/parser.ts
+init_esm_shims();
+import { z } from "zod";
+var StatusInputSchema = z.object({
+  hook_event_name: z.string().optional(),
+  session_id: z.string().optional(),
+  transcript_path: z.string().optional(),
+  cwd: z.string().optional(),
+  model: z.object({
+    id: z.string().optional(),
+    display_name: z.string().optional()
+  }).optional(),
+  workspace: z.object({
+    current_dir: z.string().optional(),
+    project_dir: z.string().optional()
+  }).optional(),
+  version: z.string().optional(),
+  output_style: z.object({
+    name: z.string().optional()
+  }).optional(),
+  cost: z.object({
+    total_cost_usd: z.number().optional(),
+    total_duration_ms: z.number().optional(),
+    total_api_duration_ms: z.number().optional(),
+    total_lines_added: z.number().optional(),
+    total_lines_removed: z.number().optional()
+  }).optional(),
+  context_window: z.object({
+    total_input_tokens: z.number().optional(),
+    total_output_tokens: z.number().optional(),
+    context_window_size: z.number().optional(),
+    used_percentage: z.number().optional(),
+    remaining_percentage: z.number().optional(),
+    current_usage: z.object({
+      input_tokens: z.number().optional(),
+      output_tokens: z.number().optional(),
+      cache_creation_input_tokens: z.number().optional(),
+      cache_read_input_tokens: 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;
+  }
+}
+async function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("readable", () => {
+      let chunk;
+      while ((chunk = process.stdin.read()) !== null) {
+        data += chunk;
+      }
+    });
+    process.stdin.on("end", () => {
+      resolve(data);
+    });
+    process.stdin.on("error", () => {
+      resolve("");
+    });
+  });
+}
+function isInteractiveMode() {
+  return process.stdin.isTTY === true;
+}
+
+// src/cli.ts
+init_formatter();
+init_themes();
+init_claude();
+init_defaults();
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+var program = new Command();
+program.name("ccsl").description("Customizable status line formatter for Claude Code CLI").version("1.0.0");
+program.command("install").description("Install ccsl to Claude Code settings.json").option("-c, --command <cmd>", "Custom command to use", "npx @vimukthid/ccsl").action(async (options) => {
+  console.log("\nInstalling ccsl to Claude Code...\n");
+  if (isInstalledInClaude()) {
+    const currentCmd = getCurrentClaudeCommand();
+    console.log(`  Already installed with command: ${currentCmd}`);
+    console.log("  Updating configuration...\n");
+  }
+  const backupPath = backupClaudeSettings();
+  if (backupPath) {
+    console.log(`  Backup created: ${backupPath}`);
+  }
+  const success = installToClaudeSettings(options.command);
+  if (success) {
+    console.log(`  Installed to: ${getClaudeSettingsPath()}`);
+    console.log(`  Command: ${options.command}`);
+    console.log("\n  ccsl is now configured for Claude Code!");
+    console.log("  Restart Claude Code to see your new status line.\n");
+  } else {
+    console.error("\n  Failed to install. Check file permissions.\n");
+    process.exit(1);
+  }
+});
+program.command("uninstall").description("Remove ccsl from Claude Code settings.json").action(async () => {
+  console.log("\nRemoving ccsl from Claude Code...\n");
+  if (!isInstalledInClaude()) {
+    console.log("  ccsl is not currently installed in Claude Code.\n");
+    return;
+  }
+  const backupPath = backupClaudeSettings();
+  if (backupPath) {
+    console.log(`  Backup created: ${backupPath}`);
+  }
+  const success = uninstallFromClaudeSettings();
+  if (success) {
+    console.log("  Successfully removed from Claude Code settings.\n");
+  } else {
+    console.error("\n  Failed to uninstall. Check file permissions.\n");
+    process.exit(1);
+  }
+});
+program.command("theme [name]").description("Quick switch theme or list available themes").option("-l, --list", "List available themes").action(async (name, options) => {
+  if (options.list || !name) {
+    listThemes();
+    return;
+  }
+  await switchTheme(name);
+});
+program.command("preview").description("Preview current configuration with sample data").action(async () => {
+  await previewConfig();
+});
+program.command("init").description("Create local config file").option("-g, --global", "Create global config file instead").action(async (options) => {
+  const scope = options.global ? "global" : "local";
+  await initConfig(scope);
+});
+program.command("config").description("Open TUI configuration").option("-g, --global", "Configure global settings").option("-l, --local", "Configure local project settings").action(async (options) => {
+  const scope = options.global ? "global" : "local";
+  await runTui(scope);
+});
+program.action(async () => {
+  if (isInteractiveMode()) {
+    await runTui("local");
+  } else {
+    const stdinData = await readStdin();
+    const input = parseStatusInput(stdinData);
+    if (!input) {
+      console.log("");
+      return;
+    }
+    const config = await loadConfig();
+    const output = formatStatusLine(input, config);
+    console.log(output);
+  }
+});
+async function runTui(scope) {
+  const { launchTui: launchTui2 } = await Promise.resolve().then(() => (init_app(), app_exports));
+  await launchTui2(scope);
+}
+function listThemes() {
+  console.log("\nAvailable themes:\n");
+  const descriptions = {
+    neon: "Vibrant cyberpunk with electric colors",
+    rainbow: "Colorful gradient transitions",
+    ocean: "Cool blues and teals",
+    minimal: "Clean, understated (default)",
+    monochrome: "Pure grayscale",
+    corporate: "Professional muted blues"
+  };
+  for (const name of themeNames) {
+    const desc = descriptions[name] || "";
+    console.log(`  ${name.padEnd(12)} - ${desc}`);
+  }
+  console.log("\nUse 'ccsl theme <name>' to switch themes");
+  console.log("Use 'ccsl preview' to see the current theme\n");
+}
+async function switchTheme(themeName) {
+  if (!themeNames.includes(themeName)) {
+    console.error(`
+Error: Unknown theme '${themeName}'`);
+    console.log(`Available themes: ${themeNames.join(", ")}
+`);
+    process.exit(1);
+  }
+  const configPath = getConfigPath("local");
+  const config = await loadConfig();
+  config.theme = themeName;
+  try {
+    const dir = dirname3(configPath);
+    if (!existsSync3(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    writeFileSync3(configPath, JSON.stringify(config, null, 2));
+    console.log(`
+Theme switched to '${themeName}'
+`);
+    const output = formatStatusLine(sampleStatusInput, config);
+    console.log("Preview:");
+    console.log(output);
+    console.log("");
+  } catch (err) {
+    console.error(`
+Error saving config: ${err}
+`);
+    process.exit(1);
+  }
+}
+async function previewConfig() {
+  const config = await loadConfig();
+  console.log("\nCurrent configuration:");
+  console.log(`  Theme: ${config.theme}`);
+  console.log(`  Widgets: ${config.widgets.join(", ")}`);
+  console.log(`  Separator: "${config.separator}"`);
+  console.log(`  Icons: ${config.icons}`);
+  console.log("\nPreview with sample data:\n");
+  console.log(formatStatusLine(sampleStatusInput, config));
+  console.log("");
+  if (isInstalledInClaude()) {
+    console.log(`Claude Code: Installed (${getCurrentClaudeCommand()})`);
+  } else {
+    console.log("Claude Code: Not installed (run 'ccsl install')");
+  }
+  console.log("");
+}
+async function initConfig(scope) {
+  const configPath = getConfigPath(scope);
+  if (existsSync3(configPath)) {
+    console.log(`
+Config file already exists at ${configPath}
+`);
+    return;
+  }
+  try {
+    const dir = dirname3(configPath);
+    if (!existsSync3(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    writeFileSync3(configPath, JSON.stringify(defaultConfig, null, 2));
+    console.log(`
+Created config file at ${configPath}
+`);
+  } catch (err) {
+    console.error(`
+Error creating config: ${err}
+`);
+    process.exit(1);
+  }
+}
+program.parse();
+//# sourceMappingURL=cli.js.map