azclaude-copilot 0.5.1 → 0.5.3

package/README.md

@@ -758,11 +758,11 @@ An agent is a sub-process. Use one when work must happen **in parallel** or **in
 
 ## Verified
 
-1758 tests. Every template, command, capability, agent, hook, and CLI feature verified.
+1767 tests. Every template, command, capability, agent, hook, and CLI feature verified.
 
 ```bash
 bash tests/test-features.sh
-# Results: 1758 passed, 0 failed, 1758 total
+# Results: 1767 passed, 0 failed, 1767 total
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azclaude-copilot",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "AI coding environment — 39 commands, 10 skills, 15 agents, memory, reflexes, evolution. Install: npx azclaude-copilot@latest, then open Claude Code.",
   "bin": {
     "azclaude": "bin/cli.js",

package/templates/scripts/statusline.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 // AZCLAUDE statusline — auto-installed by setup
-// Shows: model | context % (color-coded) | rate limit | session time | lines changed
+// Shows: model | context bar | git branch | rate limit | cache | time | lines | cost
 // Updates automatically after every turn — no manual action needed.
 // Zero dependencies — uses only Node.js (already required by AZCLAUDE).
 'use strict';
 
+const { execSync } = require('child_process');
+
 let raw = '';
 process.stdin.setEncoding('utf8');
 process.stdin.on('data', chunk => { raw += chunk; });
@@ -25,6 +27,36 @@ process.stdin.on('end', () => {
   const linesDel = data.cost?.total_lines_removed || 0;
   const rate5h   = data.rate_limits?.five_hour?.used_percentage ?? -1;
 
+  // Token details
+  const inputTok   = data.context_window?.total_input_tokens || 0;
+  const outputTok  = data.context_window?.total_output_tokens || 0;
+  const cachWrite  = data.context_window?.current_usage?.cache_creation_input_tokens || 0;
+  const cachRead   = data.context_window?.current_usage?.cache_read_input_tokens || 0;
+
+  // ── Agent + Skill usage (from observations.jsonl — tracked by post-tool-use hook) ──
+  const fs   = require('fs');
+  const path = require('path');
+  const projectDir = data.workspace?.current_dir || data.workspace?.project_dir || process.cwd();
+  const sessionPid = process.ppid || process.pid;
+  let agentCount = 0, skillCount = 0;
+  try {
+    const obsPath = path.join(projectDir, '.claude', 'memory', 'reflexes', 'observations.jsonl');
+    if (fs.existsSync(obsPath)) {
+      const lines = fs.readFileSync(obsPath, 'utf8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        try {
+          const obs = JSON.parse(line);
+          // Count only this session's observations
+          if (String(obs.session) !== String(sessionPid)) continue;
+          if (obs.tool === 'Agent' || obs.tool === 'Task') agentCount++;
+          if (obs.tool === 'Skill') skillCount++;
+          // Also count Read calls on SKILL.md files as skill usage
+          if (obs.tool === 'Read' && obs.file && /skills\/.*SKILL\.md/.test(obs.file)) skillCount++;
+        } catch (_) {}
+      }
+    }
+  } catch (_) {}
+
   // ── Format helpers ──
   const durSec = Math.floor(durMs / 1000);
   const mins   = Math.floor(durSec / 60);
@@ -32,10 +64,50 @@ process.stdin.on('end', () => {
 
   const ctxLabel = ctxSize >= 1000000 ? '1M' : ctxSize >= 100000 ? '200k' : String(ctxSize);
 
+  // Format large token numbers: 1234567 → 1.2M, 12345 → 12k
+  function fmtTok(n) {
+    if (n >= 1000000) return (n / 1000000).toFixed(1) + 'M';
+    if (n >= 1000)    return (n / 1000).toFixed(0) + 'k';
+    return String(n);
+  }
+
+  // ── Git info (cached — fast on subsequent calls) ──
+  let gitBranch = '';
+  let gitDirty  = 0;
+  try {
+    gitBranch = execSync('git branch --show-current 2>/dev/null', { encoding: 'utf8', timeout: 2000 }).trim();
+    const status = execSync('git status --porcelain 2>/dev/null', { encoding: 'utf8', timeout: 2000 }).trim();
+    gitDirty = status ? status.split('\n').length : 0;
+  } catch (_) {}
+
+  // ── Compaction prediction ──
+  // Estimate turns remaining before context hits 90% (compaction threshold)
+  // Uses average tokens per turn from session data
+  let compactHint = '';
+  if (ctxPct > 0 && ctxPct < 90 && inputTok > 0) {
+    const totalTok  = Math.floor(ctxSize * ctxPct / 100);
+    const remaining = Math.floor(ctxSize * 0.9) - totalTok;
+    // Rough estimate: average ~4000 tokens per turn (input + output + overhead)
+    const avgPerTurn = 4000;
+    const turnsLeft  = Math.max(1, Math.floor(remaining / avgPerTurn));
+    if (turnsLeft <= 20) {
+      compactHint = turnsLeft <= 5 ? ` ~${turnsLeft}t!` : ` ~${turnsLeft}t`;
+    }
+  }
+
+  // ── Cache hit ratio ──
+  let cacheHint = '';
+  if (cachRead > 0 || cachWrite > 0) {
+    const total = cachRead + cachWrite;
+    const hitPct = total > 0 ? Math.floor(cachRead / total * 100) : 0;
+    cacheHint = `Cache:${hitPct}%`;
+  }
+
   // ── ANSI colors ──
   const GREEN  = '\x1b[32m';
   const YELLOW = '\x1b[33m';
   const RED    = '\x1b[31m';
+  const CYAN   = '\x1b[36m';
   const DIM    = '\x1b[2m';
   const BOLD   = '\x1b[1m';
   const RESET  = '\x1b[0m';
@@ -51,20 +123,45 @@ process.stdin.on('end', () => {
   else if (ctxPct >= 60) { ctxColor = YELLOW; }
   else                   { ctxColor = GREEN;  }
 
-  // ── Line 1: model + context bar ──
+  // ── Line 1: model + context bar + compaction prediction ──
   let line1 = `${DIM}[${RESET}${BOLD}${model}${RESET}${DIM}]${RESET} `;
   line1 += `${ctxColor}${bar} ${ctxPct}%${RESET}`;
   line1 += `${DIM}/${ctxLabel}${RESET}`;
   if (ctxWarn) line1 += `${RED}${ctxWarn}${RESET}`;
+  if (compactHint) {
+    const compColor = compactHint.includes('!') ? RED : YELLOW;
+    line1 += `${compColor}${compactHint}${RESET}`;
+  }
+  // Git branch
+  if (gitBranch) {
+    line1 += ` ${DIM}|${RESET} ${CYAN}${gitBranch}${RESET}`;
+    if (gitDirty > 0) line1 += `${YELLOW}*${gitDirty}${RESET}`;
+  }
 
-  // ── Line 2: rate limit + time + lines + cost ──
+  // ── Line 2: rate limit + cache + tokens + time + lines + cost ──
   let line2 = '';
 
   // Rate limit (only show if available — Pro/Max subscription)
   if (rate5h >= 0) {
     const r = Math.floor(rate5h);
     const rColor = r >= 80 ? RED : r >= 50 ? YELLOW : DIM;
-    line2 += `${rColor}Rate: ${r}%${RESET} ${DIM}|${RESET} `;
+    line2 += `${rColor}Rate:${r}%${RESET} `;
+  }
+
+  // Cache hit ratio
+  if (cacheHint) {
+    line2 += `${DIM}${cacheHint}${RESET} `;
+  }
+
+  // Token totals
+  if (inputTok > 0 || outputTok > 0) {
+    line2 += `${DIM}In:${fmtTok(inputTok)} Out:${fmtTok(outputTok)}${RESET} `;
+  }
+
+  // Agent + Skill counts (only show if > 0 — means AZCLAUDE is being used)
+  if (agentCount > 0 || skillCount > 0) {
+    if (agentCount > 0) line2 += `${CYAN}A:${agentCount}${RESET} `;
+    if (skillCount > 0) line2 += `${CYAN}S:${skillCount}${RESET} `;
   }
 
   // Duration
@@ -72,12 +169,12 @@ process.stdin.on('end', () => {
 
   // Lines changed
   if (linesAdd > 0 || linesDel > 0) {
-    line2 += ` ${DIM}|${RESET} ${GREEN}+${linesAdd}${RESET}${DIM}/${RESET}${RED}-${linesDel}${RESET}`;
+    line2 += ` ${GREEN}+${linesAdd}${RESET}${DIM}/${RESET}${RED}-${linesDel}${RESET}`;
   }
 
   // Cost (only show if > 0 — API billing)
   if (cost > 0) {
-    line2 += ` ${DIM}|${RESET} $${cost.toFixed(2)}`;
+    line2 += ` ${DIM}$${cost.toFixed(2)}${RESET}`;
   }
 
   // ── Output ──