@oorn/claw-statusline 1.2.0

package/.claude/settings.json

@@ -0,0 +1,18 @@
+{
+  "env": {
+    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
+  },
+  "statusLine": {
+    "type": "command",
+    "command": "bash ~/.claude/statusline-command.sh"
+  },
+  "skipDangerousModePermissionPrompt": true,
+  "preferences": {
+    "tmuxSplitPanes": true
+  },
+  "voiceEnabled": true,
+  "voice": {
+    "enabled": true,
+    "mode": "hold"
+  }
+}

package/.claude/settings.local.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(cp /Users/petereai/.claude/rules/git-commits.md /Users/petereai/Desktop/projects/petereaI/dot-claude/.claude/rules/git-commits.md)",
+      "Bash(git -C /Users/petereai/Desktop/projects/petereaI/dot-claude add .claude/rules/git-commits.md)",
+      "Bash(git -C /Users/petereai/Desktop/projects/petereaI/dot-claude commit -m \"Add global rule to suppress AI attribution in git commits\")",
+      "Bash(git -C /Users/petereai/Desktop/projects/petereaI/dot-claude push)",
+      "Bash(mkdir -p /Users/petereai/Desktop/projects/petereaI/dot-claude/.claude/rules)",
+      "Bash(rm /Users/petereai/Desktop/projects/petereaI/dot-claude/.claude/rules/git-commits.md)",
+      "Bash(rm /Users/petereai/.claude/rules/git-commits.md)"
+    ]
+  }
+}

package/.claude/statusline-command.sh

@@ -0,0 +1,135 @@
+#!/usr/bin/env bash
+# Claude Code status line — usage bar style
+# Receives JSON on stdin from Claude Code
+
+input=$(cat)
+ESC=$'\033'
+
+# --- Parse JSON ---
+model=$(echo "$input" | jq -r '.model.display_name // "Claude"')
+model_id=$(echo "$input" | jq -r '.model.id // ""')
+used_pct=$(echo "$input" | jq -r '.context_window.used_percentage // "0"')
+total_tokens=$(echo "$input" | jq -r '.context_window.context_window_size // "0"')
+five_pct=$(echo "$input" | jq -r '.rate_limits.five_hour.used_percentage // empty')
+five_reset=$(echo "$input" | jq -r '.rate_limits.five_hour.resets_at // empty')
+week_pct=$(echo "$input" | jq -r '.rate_limits.seven_day.used_percentage // empty')
+
+# --- Mode detection ---
+# Subscription plans populate rate_limits; API key usage does not
+if [ -n "$five_pct" ] || [ -n "$week_pct" ]; then
+  mode="subscription"
+else
+  mode="api"
+fi
+
+# --- Build progress bar ---
+bar_width=20
+used_int=$(printf "%.0f" "$used_pct")
+filled=$(( used_int * bar_width / 100 ))
+empty=$(( bar_width - filled ))
+
+# Color based on usage
+if [ "$used_int" -lt 50 ]; then
+  bar_color="${ESC}[32m"  # green
+elif [ "$used_int" -lt 80 ]; then
+  bar_color="${ESC}[33m"  # yellow
+else
+  bar_color="${ESC}[31m"  # red
+fi
+
+# Build bar string
+bar_filled=""
+bar_empty=""
+for ((i=0; i<filled; i++)); do bar_filled+="█"; done
+for ((i=0; i<empty; i++)); do bar_empty+=" "; done
+
+# Format token counts (used/total)
+format_tokens() {
+  local t=$1
+  if [ "$t" -ge 1000 ] 2>/dev/null; then
+    echo "$(( t / 1000 ))k"
+  else
+    echo "$t"
+  fi
+}
+
+used_tokens=$(( total_tokens * used_int / 100 ))
+used_display=$(format_tokens "$used_tokens")
+total_display=$(format_tokens "$total_tokens")
+
+# --- Right-side info: rate limits (subscription) or cost estimate (API) ---
+right_info=""
+
+if [ "$mode" = "subscription" ]; then
+  # Rate limits — subscription mode
+  if [ -n "$five_pct" ]; then
+    five_int=$(printf "%.0f" "$five_pct")
+    countdown=""
+    if [ -n "$five_reset" ]; then
+      now=$(date +%s)
+      secs_left=$(( five_reset - now ))
+      if [ "$secs_left" -gt 0 ]; then
+        hrs=$(( secs_left / 3600 ))
+        mins=$(( (secs_left % 3600) / 60 ))
+        countdown=" (${hrs}h${mins}m)"
+      else
+        countdown=" (now)"
+      fi
+    fi
+    right_info="${ESC}[36m5h:${five_int}%${countdown}${ESC}[0m"
+  fi
+  if [ -n "$week_pct" ]; then
+    week_int=$(printf "%.0f" "$week_pct")
+    [ -n "$right_info" ] && right_info="$right_info "
+    right_info="${right_info}${ESC}[36m7d:${week_int}%${ESC}[0m"
+  fi
+elif [[ "$model_id" == claude-* ]]; then
+  # Cost estimate — Anthropic API mode only
+  # Pricing per million tokens (input/output). Approximate 70/30 split.
+  input_price_per_mtok=3.0
+  output_price_per_mtok=15.0
+
+  case "$model_id" in
+    claude-opus-4*)
+      input_price_per_mtok=15.0
+      output_price_per_mtok=75.0
+      ;;
+    claude-sonnet-4*|claude-sonnet-3-7*)
+      input_price_per_mtok=3.0
+      output_price_per_mtok=15.0
+      ;;
+    claude-haiku-4*|claude-haiku-3*)
+      input_price_per_mtok=0.8
+      output_price_per_mtok=4.0
+      ;;
+  esac
+
+  # Estimate cost using 70/30 input/output split of used tokens
+  cost=$(awk -v tokens="$used_tokens" \
+             -v in_price="$input_price_per_mtok" \
+             -v out_price="$output_price_per_mtok" \
+    'BEGIN {
+      input_tok  = tokens * 0.70
+      output_tok = tokens * 0.30
+      cost = (input_tok * in_price + output_tok * out_price) / 1000000
+      printf "~$%.4f", cost
+    }')
+
+  right_info="${ESC}[36m${cost}${ESC}[0m"
+# else: non-Anthropic API — tokens already shown in the bar, skip right_info
+fi
+
+if [ -n "$right_info" ]; then
+  right_info=" ${ESC}[90m|${ESC}[0m ${right_info}"
+fi
+
+# --- Output ---
+printf "%s ${ESC}[90m|${ESC}[0m [%s%s%s${ESC}[0m] %s%% ${ESC}[90m|${ESC}[0m %s/%s%s\n" \
+  "$model" \
+  "$bar_color" \
+  "$bar_filled" \
+  "$bar_empty" \
+  "$used_int" \
+  "$used_display" \
+  "$total_display" \
+  "$right_info"

package/README.md

@@ -0,0 +1,120 @@
+# claw-statusline
+
+Shared Claude Code configuration for the team — statusline, settings, and rules.
+
+## Install
+
+```bash
+npx @oorn/claw-statusline init
+```
+
+`jq` is required for the statusline. The installer will attempt to install it automatically via the available package manager on your system (Homebrew, apt, dnf, yum, pacman, zypper, apk, winget, Chocolatey, or Scoop). If auto-install fails, you'll be shown the manual command.
+
+To update to the latest version:
+
+```bash
+npx @oorn/claw-statusline@latest init
+```
+
+## What gets installed
+
+| File | Destination | Description |
+|------|-------------|-------------|
+| `settings.json` | `~/.claude/settings.json` | Claude Code preferences |
+| `statusline-command.sh` | `~/.claude/statusline-command.sh` | Status line script |
+
+## Statusline
+
+The status line is mode-aware — it adapts based on whether you're on a subscription plan or using an API key.
+
+**Subscription (Pro/Max):**
+```
+Claude Sonnet 4.6 | [████                ] 42% | 84k/200k | 5h:37% (1h22m) 7d:15%
+```
+
+**Anthropic API key (`claude-*` models):**
+```
+Claude Sonnet 4.6 | [████                ] 42% | 84k/200k | ~$0.5544
+```
+
+**3rd-party API (Gemini, MiniMax, etc.):**
+```
+Gemini 2.5 Pro | [███████████         ] 55% | 550k/1000k
+```
+
+| Segment | Description |
+|---------|-------------|
+| Model name | Current model display name |
+| `[████   ]` | Context window usage bar (green < 50%, yellow < 80%, red ≥ 80%) |
+| `42%` | Context used percentage |
+| `84k/200k` | Used tokens / total context window size |
+| `5h:37% (1h22m)` | 5-hour rate limit usage + countdown to reset *(subscription only)* |
+| `7d:15%` | 7-day rate limit usage *(subscription only)* |
+| `~$0.5544` | Estimated session cost *(Anthropic API only)* |
+
+Cost is estimated using a 70/30 input/output token split with per-model pricing:
+
+| Model | Input | Output |
+|-------|-------|--------|
+| Opus 4.x | $15/MTok | $75/MTok |
+| Sonnet 4.x / 3.7 | $3/MTok | $15/MTok |
+| Haiku 4.x / 3.x | $0.8/MTok | $4/MTok |
+
+For 3rd-party models the right section is omitted — token usage is already visible in the bar.
+
+### How it works
+
+Claude Code invokes `statusline-command.sh` after each response, passing a JSON payload via stdin. The script parses the JSON with `jq` and prints a formatted line with ANSI colors.
+
+The script is wired up in `settings.json`:
+
+```json
+"statusLine": {
+  "type": "command",
+  "command": "bash ~/.claude/statusline-command.sh"
+}
+```
+
+### Available JSON fields
+
+The full payload Claude Code sends to the script includes:
+
+```json
+{
+  "model": { "id": "claude-sonnet-4-6", "display_name": "Sonnet 4.6" },
+  "context_window": {
+    "used_percentage": 21,
+    "remaining_percentage": 79,
+    "context_window_size": 200000,
+    "total_input_tokens": 44,
+    "total_output_tokens": 7202,
+    "current_usage": {
+      "input_tokens": 1,
+      "output_tokens": 28,
+      "cache_creation_input_tokens": 219,
+      "cache_read_input_tokens": 34414
+    }
+  },
+  "rate_limits": {
+    "five_hour": { "used_percentage": 18, "resets_at": 1775725200 },
+    "seven_day": { "used_percentage": 17, "resets_at": 1776067200 }
+  },
+  "cost": {
+    "total_cost_usd": 0.67,
+    "total_lines_added": 86,
+    "total_lines_removed": 79
+  },
+  "cwd": "/Users/you/project",
+  "version": "2.1.97"
+}
+```
+
+## Updating the config
+
+1. Edit files in `.claude/`
+2. Bump version in `package.json`
+3. Update this README to reflect the change
+4. Publish and push:
+   ```bash
+   npm publish --access public && git push
+   ```

package/bin/cli.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, copyFileSync, readdirSync, statSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir, platform } from 'os';
+import { fileURLToPath } from 'url';
+import { spawnSync } from 'child_process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const { version: VERSION } = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+const CLAUDE_DIR = join(homedir(), '.claude');
+const SRC_DIR = join(__dirname, '..', '.claude');
+
+const args = process.argv.slice(2);
+
+if (args.includes('--version') || args.includes('-v')) {
+  console.log(VERSION);
+  process.exit(0);
+}
+
+if (args[0] !== 'init') {
+  console.log(`Usage: npx @oorn/claw-statusline init`);
+  process.exit(1);
+}
+
+// --- init ---
+
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const dim   = (s) => `\x1b[90m${s}\x1b[0m`;
+const bold  = (s) => `\x1b[1m${s}\x1b[0m`;
+
+console.log(`\n${bold('claw-statusline')} — installing Claude Code config\n`);
+
+function installFile(src, dest) {
+  const destDir = dirname(dest);
+  if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+  copyFileSync(src, dest);
+  const rel = dest.replace(homedir(), '~');
+  console.log(`  ${green('✓')} ${rel}`);
+}
+
+function installDir(srcDir, destDir) {
+  if (!existsSync(srcDir)) return;
+  for (const file of readdirSync(srcDir)) {
+    const src = join(srcDir, file);
+    if (statSync(src).isFile()) {
+      installFile(src, join(destDir, file));
+    }
+  }
+}
+
+// Top-level files
+for (const file of ['settings.json', 'statusline-command.sh']) {
+  const src = join(SRC_DIR, file);
+  if (existsSync(src)) installFile(src, join(CLAUDE_DIR, file));
+}
+
+// rules/
+installDir(join(SRC_DIR, 'rules'), join(CLAUDE_DIR, 'rules'));
+
+// skills/
+const skillsSrc = join(SRC_DIR, 'skills');
+if (existsSync(skillsSrc)) {
+  for (const skill of readdirSync(skillsSrc)) {
+    const skillDir = join(skillsSrc, skill);
+    if (statSync(skillDir).isDirectory()) {
+      installDir(skillDir, join(CLAUDE_DIR, 'skills', skill));
+    }
+  }
+}
+
+// --- jq check ---
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+
+function hasCmd(cmd) {
+  return spawnSync(cmd, ['--version'], { stdio: 'ignore' }).status === 0;
+}
+
+function tryInstall(label, ...args) {
+  console.log(`  ${yellow('!')} jq not found — installing via ${label}…`);
+  return spawnSync(args[0], args.slice(1), { stdio: 'inherit' }).status === 0;
+}
+
+function installJq() {
+  const os = platform();
+
+  if (os === 'darwin') {
+    if (hasCmd('brew'))   return tryInstall('Homebrew', 'brew', 'install', 'jq');
+    if (hasCmd('port'))   return tryInstall('MacPorts', 'sudo', 'port', 'install', 'jq');
+  }
+
+  if (os === 'linux') {
+    if (hasCmd('apt-get'))  return tryInstall('apt',    'sudo', 'apt-get', 'install', '-y', 'jq');
+    if (hasCmd('dnf'))      return tryInstall('dnf',    'sudo', 'dnf',     'install', '-y', 'jq');
+    if (hasCmd('yum'))      return tryInstall('yum',    'sudo', 'yum',     'install', '-y', 'jq');
+    if (hasCmd('pacman'))   return tryInstall('pacman', 'sudo', 'pacman',  '-S', '--noconfirm', 'jq');
+    if (hasCmd('zypper'))   return tryInstall('zypper', 'sudo', 'zypper',  'install', '-y', 'jq');
+    if (hasCmd('apk'))      return tryInstall('apk',    'sudo', 'apk',     'add', 'jq');
+  }
+
+  if (os === 'win32') {
+    if (hasCmd('winget'))  return tryInstall('winget', 'winget', 'install', '--id', 'jqlang.jq', '-e', '--silent');
+    if (hasCmd('choco'))   return tryInstall('Chocolatey', 'choco', 'install', 'jq', '-y');
+    if (hasCmd('scoop'))   return tryInstall('Scoop', 'scoop', 'install', 'jq');
+  }
+
+  return false;
+}
+
+if (!hasCmd('jq')) {
+  const installed = installJq();
+  if (installed) {
+    console.log(`  ${green('✓')} jq installed`);
+  } else {
+    console.log(`\n  ${yellow('!')} jq is required for the statusline but could not be installed automatically.`);
+    console.log(`  ${dim('Install it manually:')}`);
+    console.log(`  ${dim('  macOS:   brew install jq')}`);
+    console.log(`  ${dim('  Ubuntu:  sudo apt install jq')}`);
+    console.log(`  ${dim('  Fedora:  sudo dnf install jq')}`);
+    console.log(`  ${dim('  Arch:    sudo pacman -S jq')}`);
+    console.log(`  ${dim('  Alpine:  sudo apk add jq')}`);
+    console.log(`  ${dim('  Windows: winget install jqlang.jq')}`);
+  }
+} else {
+  console.log(`  ${green('✓')} jq`);
+}
+
+console.log(`\n${dim('Claude Code will pick up changes automatically.')}`);
+console.log(`${dim('To update: npx @oorn/claw-statusline@latest init')}\n`);

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@oorn/claw-statusline",
+  "version": "1.2.0",
+  "description": "Claude Code statusline, settings, and rules installer",
+  "bin": {
+    "claw-statusline": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    ".claude/"
+  ],
+  "scripts": {
+    "prepublishOnly": "node bin/cli.js --version"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "dotfiles"
+  ],
+  "author": "oorn",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}