@npow/oh-my-claude 0.1.0

package/src/compositor.js

@@ -0,0 +1,163 @@
+// src/compositor.js — Layout engine
+// Zero dependencies. Node 18+ ESM.
+
+import { stylize, stripAnsi } from './color.js';
+
+/**
+ * Detect terminal width. Safe methods only — no /dev/tty access, no shell
+ * subprocesses. Those can corrupt the terminal when run from a piped subprocess.
+ *
+ * @returns {number}
+ */
+function detectWidth() {
+  // 1. Explicit env override (user can set OMC_WIDTH in settings.json env)
+  if (process.env.OMC_WIDTH) {
+    const w = parseInt(process.env.OMC_WIDTH, 10);
+    if (w > 0) return w;
+  }
+
+  // 2. COLUMNS env var (set by some shells, inherited by subprocesses)
+  if (process.env.COLUMNS) {
+    const w = parseInt(process.env.COLUMNS, 10);
+    if (w > 0) return w;
+  }
+
+  // 3. stdout/stderr columns (works if either is still a TTY)
+  if (process.stdout.columns) return process.stdout.columns;
+  if (process.stderr.columns) return process.stderr.columns;
+
+  // 4. Fallback — most modern terminals are wider than 80
+  return 120;
+}
+
+/**
+ * Render an array of segment results into a styled string joined by separator.
+ *
+ * @param {Array<{text: string, style: string}>} parts - Segment outputs
+ * @param {string} separator - Plain separator string (will not be styled)
+ * @returns {{ rendered: string, plainLength: number }}
+ */
+function renderSide(parts, separator) {
+  if (!parts || !Array.isArray(parts) || parts.length === 0) {
+    return { rendered: '', plainLength: 0 };
+  }
+
+  const styledParts = [];
+  for (const part of parts) {
+    if (!part || part.text == null) continue;
+    const text = String(part.text);
+    if (!text) continue;
+    styledParts.push(stylize(text, part.style || ''));
+  }
+
+  if (styledParts.length === 0) {
+    return { rendered: '', plainLength: 0 };
+  }
+
+  const sep = separator || ' | ';
+  const rendered = styledParts.join(sep);
+  const plainLength = stripAnsi(rendered).length;
+
+  return { rendered, plainLength };
+}
+
+/**
+ * Compose the final statusline output from line definitions.
+ *
+ * @param {Array<{left: Array, right: Array}>} lines - Line objects with left/right segment arrays
+ * @param {number} [terminalWidth] - Terminal width override (defaults to process.stdout.columns or 80)
+ * @param {string} [separator] - Separator between segments (default: ' | ')
+ * @returns {string} Final formatted output string (lines joined by newline)
+ */
+export function compose(lines, terminalWidth, separator) {
+  if (!lines || !Array.isArray(lines) || lines.length === 0) return '';
+
+  const width = terminalWidth || detectWidth();
+  const sep = separator || ' | ';
+  const outputLines = [];
+
+  for (const line of lines) {
+    if (!line) {
+      outputLines.push('');
+      continue;
+    }
+
+    const left = renderSide(line.left, sep);
+    const right = renderSide(line.right, sep);
+
+    // If both sides are empty, skip this line entirely
+    if (!left.rendered && !right.rendered) continue;
+
+    // If only one side has content
+    if (!right.rendered) {
+      outputLines.push(left.rendered);
+      continue;
+    }
+    if (!left.rendered) {
+      // Right-align: pad with spaces
+      const padding = Math.max(0, width - right.plainLength);
+      outputLines.push(' '.repeat(padding) + right.rendered);
+      continue;
+    }
+
+    // Both sides have content — fill middle with spaces
+    const usedWidth = left.plainLength + right.plainLength;
+    const gap = width - usedWidth;
+
+    if (gap >= 1) {
+      // Plenty of room — pad the middle
+      outputLines.push(left.rendered + ' '.repeat(gap) + right.rendered);
+    } else {
+      // Terminal too narrow — truncate left side to make room for right
+      // We need at least right.plainLength + 1 char for "..." truncation indicator
+      const available = width - right.plainLength - 1;
+
+      if (available <= 0) {
+        // Not enough room for anything on the left — just show right
+        outputLines.push(right.rendered);
+      } else {
+        // Truncate the left side's plain text and re-render
+        // We walk the rendered string character by character, tracking visible length
+        const truncated = truncateAnsi(left.rendered, available);
+        outputLines.push(truncated + '\x1b[0m' + ' ' + right.rendered);
+      }
+    }
+  }
+
+  return outputLines.join('\n');
+}
+
+/**
+ * Truncate an ANSI-styled string to a given visible character count.
+ * Preserves ANSI codes but cuts visible characters.
+ *
+ * @param {string} str - ANSI-styled string
+ * @param {number} maxVisible - Maximum visible character count
+ * @returns {string} Truncated string
+ */
+function truncateAnsi(str, maxVisible) {
+  if (!str) return '';
+  if (maxVisible <= 0) return '';
+
+  let visible = 0;
+  let result = '';
+  let i = 0;
+
+  while (i < str.length && visible < maxVisible) {
+    // Check for ANSI escape sequence
+    if (str[i] === '\x1b' && str[i + 1] === '[') {
+      // Find end of CSI sequence (ends at a letter)
+      let j = i + 2;
+      while (j < str.length && !/[A-Za-z]/.test(str[j])) j++;
+      if (j < str.length) j++; // include the terminating letter
+      result += str.slice(i, j);
+      i = j;
+    } else {
+      result += str[i];
+      visible++;
+      i++;
+    }
+  }
+
+  return result;
+}

package/src/config.js

@@ -0,0 +1,146 @@
+// src/config.js — Configuration loader
+// Zero dependencies. Node 18+ ESM.
+
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = join(__dirname, '..');
+const THEMES_DIR = join(PACKAGE_ROOT, 'themes');
+const DEFAULT_USER_CONFIG_PATH = join(homedir(), '.claude', 'oh-my-claude', 'config.json');
+
+/**
+ * Deep merge source into target (mutates target).
+ * Arrays are replaced, not merged.
+ *
+ * @param {object} target
+ * @param {object} source
+ * @returns {object} The merged target
+ */
+function deepMerge(target, source) {
+  if (!source || typeof source !== 'object' || Array.isArray(source)) return target;
+  if (!target || typeof target !== 'object' || Array.isArray(target)) return source;
+
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtVal = target[key];
+
+    if (
+      srcVal && typeof srcVal === 'object' && !Array.isArray(srcVal) &&
+      tgtVal && typeof tgtVal === 'object' && !Array.isArray(tgtVal)
+    ) {
+      target[key] = deepMerge(tgtVal, srcVal);
+    } else {
+      target[key] = srcVal;
+    }
+  }
+
+  return target;
+}
+
+/**
+ * Read and parse a JSON file. Returns null on any failure.
+ *
+ * @param {string} filepath
+ * @returns {object|null}
+ */
+function readJson(filepath) {
+  try {
+    const raw = readFileSync(filepath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Returns the hardcoded default theme configuration.
+ * Used as ultimate fallback if no theme files are found.
+ *
+ * @returns {object}
+ */
+export function getDefaultConfig() {
+  return {
+    separator: ' | ',
+    lines: [
+      {
+        left: ['model', 'context', 'cost'],
+        right: ['project'],
+      },
+    ],
+    segments: {
+      model: {
+        style: 'bold cyan',
+      },
+      context: {
+        style: 'yellow',
+        warn_threshold: 60,
+        critical_threshold: 80,
+        warn_style: 'bold yellow',
+        critical_style: 'bold red',
+      },
+      cost: {
+        style: 'green',
+        warn_threshold: 5,
+        critical_threshold: 10,
+        warn_style: 'bold yellow',
+        critical_style: 'bold red',
+      },
+      project: {
+        style: 'blue',
+      },
+    },
+  };
+}
+
+/**
+ * Load a theme file by name from the themes/ directory.
+ *
+ * @param {string} themeName - Theme name (without .json extension)
+ * @returns {object|null} Parsed theme config or null
+ */
+function loadTheme(themeName) {
+  if (!themeName || typeof themeName !== 'string') return null;
+  const themePath = join(THEMES_DIR, `${themeName}.json`);
+  return readJson(themePath);
+}
+
+/**
+ * Load the full configuration by merging theme + user overrides.
+ *
+ * Resolution order:
+ *   1. Start with hardcoded default config
+ *   2. Load theme file specified by user config (or "default" theme)
+ *   3. Deep merge theme on top of defaults
+ *   4. Deep merge user's per-segment config on top
+ *   5. Return final config
+ *
+ * @param {string} [userConfigPath] - Path to user config file (defaults to ~/.claude/oh-my-claude/config.json)
+ * @returns {object} Final merged configuration
+ */
+export function loadConfig(userConfigPath) {
+  const configPath = userConfigPath || DEFAULT_USER_CONFIG_PATH;
+
+  // Start with hardcoded defaults
+  let config = getDefaultConfig();
+
+  // Read user config to determine theme name
+  const userConfig = readJson(configPath);
+  const themeName = (userConfig && userConfig.theme) || 'default';
+
+  // Load and merge theme
+  const themeConfig = loadTheme(themeName);
+  if (themeConfig) {
+    config = deepMerge(config, themeConfig);
+  }
+
+  // Merge user per-segment overrides
+  if (userConfig && userConfig.segments) {
+    if (!config.segments) config.segments = {};
+    config.segments = deepMerge(config.segments, userConfig.segments);
+  }
+
+  return config;
+}

package/src/plugins.js

@@ -0,0 +1,72 @@
+// src/plugins.js — Plugin discovery and loading
+// Zero dependencies. Node 18+ ESM.
+//
+// Scans ~/.claude/oh-my-claude/plugins/<name>/segment.js for user-defined segments.
+// Each plugin must export `meta` (object with `name` string) and `render` (function).
+// Bad or missing plugins are silently skipped — never crash the statusline.
+
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { pathToFileURL } from 'node:url';
+
+const PLUGINS_DIR = join(homedir(), '.claude', 'oh-my-claude', 'plugins');
+
+/**
+ * Discover and load all valid plugins from the plugins directory.
+ *
+ * @returns {Promise<Record<string, { meta: object, render: function }>>}
+ *   A map of { [meta.name]: module } for all valid plugins.
+ *   Returns an empty object if the directory doesn't exist or no valid plugins are found.
+ */
+export async function discoverPlugins() {
+  const plugins = {};
+
+  // 1. List subdirectories — bail silently if dir doesn't exist
+  let entries;
+  try {
+    entries = readdirSync(PLUGINS_DIR);
+  } catch {
+    return plugins;
+  }
+
+  // 2. For each entry, check if it's a directory with a segment.js
+  for (const entry of entries) {
+    try {
+      const entryPath = join(PLUGINS_DIR, entry);
+      const stat = statSync(entryPath);
+      if (!stat.isDirectory()) continue;
+
+      const segmentPath = join(entryPath, 'segment.js');
+
+      // Verify segment.js exists before attempting import
+      try {
+        statSync(segmentPath);
+      } catch {
+        continue;
+      }
+
+      // 3. Dynamic import — use file:// URL for cross-platform ESM compatibility
+      const mod = await import(pathToFileURL(segmentPath).href);
+
+      // 4. Validate exports: must have meta.name (string) and render (function)
+      if (!mod.meta || typeof mod.meta.name !== 'string' || !mod.meta.name) continue;
+      if (typeof mod.render !== 'function') continue;
+
+      plugins[mod.meta.name] = mod;
+    } catch {
+      // Bad plugin — skip silently, never crash the statusline
+      continue;
+    }
+  }
+
+  return plugins;
+}
+
+/**
+ * Return the plugins directory path (used by CLI commands).
+ * @returns {string}
+ */
+export function getPluginsDir() {
+  return PLUGINS_DIR;
+}

package/src/runner.js

@@ -0,0 +1,160 @@
+// src/runner.js — Main entry point
+// Zero dependencies. Node 18+ ESM.
+// Claude Code pipes JSON to stdin, we output a formatted statusline to stdout.
+//
+// CRITICAL: This script runs as a piped subprocess. Claude Code may kill the
+// pipe at any time (e.g., user starts typing, debounce fires). We MUST handle
+// EPIPE gracefully and ensure ANSI state is always reset to avoid corrupting
+// the terminal.
+
+import { loadConfig } from './config.js';
+import { compose } from './compositor.js';
+import { segments } from './segments/index.js';
+import { discoverPlugins } from './plugins.js';
+
+// Silently ignore EPIPE — Claude Code closing the pipe is normal, not an error.
+process.stdout.on('error', (err) => {
+  if (err.code === 'EPIPE') process.exit(0);
+});
+process.on('uncaughtException', (err) => {
+  if (err.code === 'EPIPE') process.exit(0);
+  process.exit(0); // Any other crash: exit cleanly, never hang
+});
+
+/**
+ * Read all of stdin as a string.
+ * @returns {Promise<string>}
+ */
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+
+    // If stdin is a TTY (no piped data), resolve immediately with empty string
+    if (process.stdin.isTTY) {
+      resolve('');
+      return;
+    }
+
+    process.stdin.setEncoding('utf8');
+
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+
+    process.stdin.on('end', () => {
+      resolve(data);
+    });
+
+    process.stdin.on('error', () => {
+      resolve('');
+    });
+  });
+}
+
+/**
+ * Main execution.
+ */
+async function main() {
+  try {
+    // 1. Read stdin JSON
+    const raw = await readStdin();
+    if (!raw.trim()) {
+      process.stdout.write('');
+      return;
+    }
+
+    // 2. Parse JSON
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      process.stdout.write('');
+      return;
+    }
+
+    // 3. Load config
+    const config = loadConfig();
+    const separator = config.separator || ' | ';
+
+    // 4. Discover plugins and merge with built-in segments
+    //    Plugins override built-ins if they share the same name.
+    let allSegments = segments;
+    try {
+      const plugins = await discoverPlugins();
+      if (Object.keys(plugins).length > 0) {
+        allSegments = { ...segments, ...plugins };
+      }
+    } catch {
+      // Plugin discovery failed — continue with built-ins only
+    }
+
+    // 5. Process each line from config
+    const lineResults = [];
+
+    const configLines = config.lines;
+    if (!configLines || !Array.isArray(configLines)) {
+      process.stdout.write('');
+      return;
+    }
+
+    for (const lineDef of configLines) {
+      if (!lineDef) continue;
+
+      const leftParts = renderSegments(lineDef.left, data, config, allSegments);
+      const rightParts = renderSegments(lineDef.right, data, config, allSegments);
+
+      lineResults.push({ left: leftParts, right: rightParts });
+    }
+
+    // 6. Compose and output — always end with ANSI reset to prevent state leaking
+    const output = compose(lineResults, undefined, separator);
+    process.stdout.write(output + '\x1b[0m');
+  } catch {
+    // If ANYTHING fails, reset ANSI and exit cleanly
+    try { process.stdout.write('\x1b[0m'); } catch {}
+  }
+}
+
+/**
+ * Render an array of segment names into an array of {text, style} results.
+ *
+ * @param {string[]} segmentNames - Array of segment names from config
+ * @param {object} data - Parsed stdin JSON data
+ * @param {object} config - Full merged config
+ * @param {Record<string, { render: function }>} segmentRegistry - Map of segment name to module
+ * @returns {Array<{text: string, style: string}>}
+ */
+function renderSegments(segmentNames, data, config, segmentRegistry) {
+  if (!segmentNames || !Array.isArray(segmentNames)) return [];
+
+  const results = [];
+
+  for (const name of segmentNames) {
+    if (!name || typeof name !== 'string') continue;
+
+    const segment = segmentRegistry[name];
+    if (!segment || typeof segment.render !== 'function') continue;
+
+    const segmentConfig = (config.segments && config.segments[name]) || {};
+
+    try {
+      const result = segment.render(data, segmentConfig);
+      if (result == null) continue;
+      if (typeof result === 'string') {
+        results.push({ text: result, style: segmentConfig.style || '' });
+      } else if (result.text != null) {
+        results.push({
+          text: String(result.text),
+          style: result.style || segmentConfig.style || '',
+        });
+      }
+    } catch {
+      // Segment threw — skip it silently
+      continue;
+    }
+  }
+
+  return results;
+}
+
+main();

package/src/segments/achievement.js

@@ -0,0 +1,68 @@
+// src/segments/achievement.js — Unlockable achievement badges for session milestones
+// Zero dependencies. Node 18+ ESM.
+
+const ACHIEVEMENTS = [
+  { id: 'first-blood', check: d => (d?.cost?.total_lines_added ?? 0) > 0, text: '\u{1F3C6} First Blood', desc: 'first edit' },
+  { id: 'centurion', check: d => (d?.cost?.total_lines_added ?? 0) >= 100, text: '\u{1F4AF} Centurion', desc: '100+ lines' },
+  { id: 'architect', check: d => (d?.cost?.total_lines_added ?? 0) >= 500, text: '\u{1F3D7}\uFE0F Architect', desc: '500+ lines' },
+  { id: 'novelist', check: d => (d?.cost?.total_lines_added ?? 0) >= 1000, text: '\u{1F4D6} Novelist', desc: '1000+ lines' },
+  { id: 'marie-kondo', check: d => (d?.cost?.total_lines_removed ?? 0) > (d?.cost?.total_lines_added ?? 0) && (d?.cost?.total_lines_removed ?? 0) > 10, text: '\u{1F9F9} Marie Kondo', desc: 'net negative' },
+  { id: 'big-spender', check: d => (d?.cost?.total_cost_usd ?? 0) >= 5, text: '\u{1F4B0} Big Spender', desc: '$5+ session' },
+  { id: 'whale', check: d => (d?.cost?.total_cost_usd ?? 0) >= 20, text: '\u{1F40B} Whale', desc: '$20+ session' },
+  { id: 'marathon', check: d => (d?.cost?.total_duration_ms ?? 0) >= 3600000, text: '\u{1F3C3} Marathon', desc: '1hr+ session' },
+  { id: 'ultramarathon', check: d => (d?.cost?.total_duration_ms ?? 0) >= 7200000, text: '\u{1F3C5} Ultramarathon', desc: '2hr+ session' },
+  { id: 'half-full', check: d => (d?.context_window?.used_percentage ?? 0) >= 50, text: '\u23F3 Half Full', desc: '50% context' },
+  { id: 'danger-zone', check: d => (d?.context_window?.used_percentage ?? 0) >= 80, text: '\u26A0\uFE0F Danger Zone', desc: '80% context' },
+  { id: 'the-brink', check: d => (d?.context_window?.used_percentage ?? 0) >= 95, text: '\u{1F480} The Brink', desc: '95% context' },
+];
+
+// Module-level state: tracks which achievements have already been displayed
+const shown = new Set();
+let currentDisplay = null;
+let displayCount = 0;
+
+export const meta = {
+  name: 'achievement',
+  description: 'Shows achievement badges that unlock based on session milestones',
+  requires: [],
+  defaultConfig: {
+    style: 'bold cyan',
+  },
+};
+
+/**
+ * @param {object} data - Parsed stdin JSON from Claude Code
+ * @param {object} config - Per-segment config from theme
+ * @returns {{text: string, style: string}|null}
+ */
+export function render(data, config) {
+  const cfg = { ...meta.defaultConfig, ...config };
+
+  // Find the first achievement that is (a) passing its check and (b) not yet shown
+  let newUnlock = null;
+  for (const achievement of ACHIEVEMENTS) {
+    if (!shown.has(achievement.id) && achievement.check(data)) {
+      newUnlock = achievement;
+      break;
+    }
+  }
+
+  if (newUnlock) {
+    shown.add(newUnlock.id);
+    currentDisplay = newUnlock;
+    displayCount = 0;
+  }
+
+  if (currentDisplay == null) return null;
+
+  displayCount++;
+
+  // After being displayed for 3+ renders, fade away
+  if (displayCount > 3) {
+    currentDisplay = null;
+    displayCount = 0;
+    return null;
+  }
+
+  return { text: currentDisplay.text, style: cfg.style };
+}

package/src/segments/api-timer.js

@@ -0,0 +1,55 @@
+// src/segments/api-timer.js — Display cumulative API wait time
+// Zero dependencies. Node 18+ ESM.
+
+export const meta = {
+  name: 'api-timer',
+  description: 'Shows cumulative API duration (total_api_duration_ms)',
+  requires: [],
+  defaultConfig: {
+    style: 'dim',
+    label: 'api',
+    icon: false,
+  },
+};
+
+/**
+ * Format milliseconds into a human-friendly duration string.
+ * Examples: "3s", "1m 24s", "2h 5m"
+ *
+ * @param {number} ms
+ * @returns {string}
+ */
+function formatDuration(ms) {
+  const totalSeconds = Math.floor(ms / 1000);
+  if (totalSeconds < 1) return '0s';
+
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+
+  if (hours > 0) {
+    return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+  }
+  if (minutes > 0) {
+    return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+  }
+  return `${seconds}s`;
+}
+
+/**
+ * @param {object} data - Parsed stdin JSON from Claude Code
+ * @param {object} config - Per-segment config from theme
+ * @returns {{text: string, style: string}|null}
+ */
+export function render(data, config) {
+  const cfg = { ...meta.defaultConfig, ...config };
+
+  const ms = data?.cost?.total_api_duration_ms;
+  if (!ms) return null;
+
+  const duration = formatDuration(ms);
+  let text = cfg.label ? `${cfg.label} ${duration}` : duration;
+  if (cfg.icon) text = `\u{F0527} ${text}`;
+
+  return { text, style: cfg.style };
+}