gramatr 0.3.0

package/bin/render-claude-hooks.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+import { buildClaudeHooksFile } from '../core/install.ts';
+
+function main(): void {
+  const clientDir = process.argv[2];
+  if (!clientDir) {
+    throw new Error('Usage: render-claude-hooks.ts <client-dir>');
+  }
+
+  const includeOptionalUx = process.env.GMTR_ENABLE_OPTIONAL_CLAUDE_UX === '1';
+  const hooks = buildClaudeHooksFile(clientDir, { includeOptionalUx });
+  process.stdout.write(`${JSON.stringify(hooks.hooks, null, 2)}\n`);
+}
+
+main();

package/bin/statusline.ts

@@ -0,0 +1,437 @@
+#!/usr/bin/env node
+/**
+ * gramatr Status Line — TypeScript rewrite of statusline.sh (#158)
+ *
+ * Single source of truth: gramatr API for server metrics, local for git/env.
+ * Replaces 1,383-line bash script with type-safe, testable TypeScript.
+ *
+ * Data sources:
+ *   API  → entity count, token savings, classifier stats, learning signals, skills, version
+ *   Local → git status, context window, Anthropic usage, session label, location/weather (cached)
+ *   Stdin → Claude Code JSON (context_window, session_id, model, workspace)
+ */
+
+import { readFileSync, existsSync, writeFileSync, statSync } from 'fs';
+import { execSync } from 'child_process';
+import { join } from 'path';
+
+// ── Types ──────────────────────────────────────────────────────────────────
+
+interface CCInput {
+  workspace?: { current_dir?: string };
+  cwd?: string;
+  session_id?: string;
+  model?: { display_name?: string };
+  version?: string;
+  cost?: { total_duration_ms?: number };
+  context_window?: {
+    context_window_size?: number;
+    used_percentage?: number;
+    remaining_percentage?: number;
+    total_input_tokens?: number;
+    total_output_tokens?: number;
+  };
+}
+
+interface GramatrStats {
+  server_version: string;
+  entity_count: number;
+  observation_count: number;
+  search_count: number;
+  tokens_saved_total: number;
+  tokens_saved_7d: number;
+  classifications_total: number;
+  classifications_7d: number;
+  operations_1h: number;
+  operations_24h: number;
+  classifier: {
+    level: number;
+    model: string;
+    accuracy: number;
+    feedback_rate: number;
+    total_classifications: number;
+  };
+  learning: {
+    latest: number | null;
+    avg_1d: number | null;
+    avg_1w: number | null;
+    avg_1mo: number | null;
+    count: number;
+  };
+  skills_count: number;
+}
+
+interface GitInfo {
+  projectId: string;  // org/repo from remote, fallback to directory name
+  branch: string;
+  stashCount: number;
+  modified: number;
+  untracked: number;
+  ahead: number;
+  behind: number;
+  lastCommitAge: string;
+  lastCommitColor: string;
+}
+
+
+
+// ── Config ─────────────────────────────────────────────────────────────────
+
+const HOME = process.env.HOME || '';
+const GMTR_DIR = process.env.GMTR_DIR || join(HOME, 'gmtr-client');
+const STATE_DIR = join(GMTR_DIR, '.state');
+const SETTINGS_PATH = join(HOME, '.claude', 'settings.json');
+
+function getGramatrUrl(): string {
+  try {
+    const claude = JSON.parse(readFileSync(join(HOME, '.claude.json'), 'utf8'));
+    return claude?.mcpServers?.gramatr?.url?.replace('/mcp', '') || 'https://api.gramatr.com';
+  } catch {
+    return 'https://api.gramatr.com';
+  }
+}
+
+function getAuthToken(): string {
+  // Check settings.json first, then env var
+  try {
+    const settings = JSON.parse(readFileSync(join(GMTR_DIR, 'settings.json'), 'utf8'));
+    if (settings?.auth?.token) return settings.auth.token;
+  } catch { /* no settings file */ }
+  return process.env.GMTR_TOKEN || process.env.AIOS_MCP_TOKEN || '';
+}
+
+// ── Cache Helper ───────────────────────────────────────────────────────────
+
+function readCache<T>(path: string, ttlMs: number): T | null {
+  try {
+    if (!existsSync(path)) return null;
+    const stat = statSync(path);
+    if (Date.now() - stat.mtimeMs > ttlMs) return null;
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(path: string, data: unknown): void {
+  try {
+    writeFileSync(path, JSON.stringify(data));
+  } catch { /* non-critical */ }
+}
+
+// ── Colors (24-bit ANSI) ───────────────────────────────────────────────────
+
+// Gray Matter palette — from design-tokens.json (locked 2026-03-28)
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  // Text hierarchy (warm neutrals)
+  text: '\x1b[38;2;236;236;236m',       // #ECECEC — primary text
+  textSec: '\x1b[38;2;136;136;136m',    // #888888 — secondary
+  textMuted: '\x1b[38;2;102;102;102m',  // #666666 — muted/labels
+  // Brand
+  primary: '\x1b[38;2;59;130;246m',     // #3B82F6 — blue accent
+  accent: '\x1b[38;2;96;165;250m',      // #60A5FA — lighter blue
+  // Structural
+  border: '\x1b[38;2;51;51;51m',        // #333333 — separators
+  surface: '\x1b[38;2;26;26;26m',       // #1A1A1A — surface
+  // Semantic
+  success: '\x1b[38;2;74;222;128m',     // #4ADE80
+  warning: '\x1b[38;2;250;204;21m',     // #FACC15
+  error: '\x1b[38;2;248;113;113m',      // #F87171
+  // Bg
+  barBg: '\x1b[48;2;26;26;26m',         // #1A1A1A — context bar empty
+};
+
+function ageColor(age: string): string {
+  if (age.endsWith('m') && parseInt(age) < 30) return c.success;
+  if (age.endsWith('h') && parseInt(age) < 2) return c.accent;
+  if (age.endsWith('d') && parseInt(age) < 2) return c.warning;
+  return c.error;
+}
+
+// ── Data Fetchers ──────────────────────────────────────────────────────────
+
+async function fetchGramatrStats(): Promise<GramatrStats | null> {
+  const cached = readCache<GramatrStats>(join(STATE_DIR, 'api-stats-cache.json'), 60_000);
+  if (cached) return cached;
+
+  const url = getGramatrUrl();
+  const token = getAuthToken();
+  if (!token) return null;
+
+  try {
+    const resp = await fetch(`${url}/api/v1/stats/statusline`, {
+      headers: { 'Authorization': `Bearer ${token}`, 'Accept': 'application/json' },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!resp.ok) {
+      // Fallback: read from local files if API not available yet
+      return readLocalStats();
+    }
+    const data = await resp.json() as GramatrStats;
+    writeCache(join(STATE_DIR, 'api-stats-cache.json'), data);
+    return data;
+  } catch {
+    // API unavailable — fall back to local files
+    return readLocalStats();
+  }
+}
+
+function readLocalStats(): GramatrStats | null {
+  // Backward-compatible: read from /tmp/ files (same as bash version)
+  try {
+    const stats = existsSync('/tmp/gmtr-stats.json')
+      ? JSON.parse(readFileSync('/tmp/gmtr-stats.json', 'utf8'))
+      : {};
+    const savings = existsSync('/tmp/gmtr-classification-savings.json')
+      ? JSON.parse(readFileSync('/tmp/gmtr-classification-savings.json', 'utf8'))
+      : {};
+
+    // Sum tokens from history
+    let totalTokensSaved = 0;
+    let ops1h = 0;
+    let ops24h = 0;
+    const now = Date.now();
+    if (existsSync('/tmp/gmtr-op-history.jsonl')) {
+      const lines = readFileSync('/tmp/gmtr-op-history.jsonl', 'utf8').trim().split('\n');
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          totalTokensSaved += entry.tokens_saved || 0;
+          const age = now - (entry.timestamp || 0);
+          if (age < 3600_000) ops1h++;
+          if (age < 86400_000) ops24h++;
+        } catch { /* skip bad lines */ }
+      }
+    }
+
+    return {
+      server_version: savings.server_version || '',
+      entity_count: stats.entity_count || 0,
+      observation_count: stats.observation_count || 0,
+      search_count: stats.search_count || 0,
+      tokens_saved_total: 0,
+      tokens_saved_7d: 0,
+      classifications_total: 0,
+      classifications_7d: 0,
+      operations_1h: ops1h,
+      operations_24h: ops24h,
+      classifier: {
+        level: stats.classifier_level || 0,
+        model: stats.classifier_model || savings.qwen_model || '',
+        accuracy: stats.accuracy || 0,
+        feedback_rate: stats.feedback_rate || 0,
+        total_classifications: stats.total_classifications || 0,
+      },
+      learning: { latest: null, avg_1d: null, avg_1w: null, avg_1mo: null, count: 0 },
+      skills_count: 0,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function getGitInfo(cwd: string): GitInfo | null {
+  try {
+    const run = (cmd: string) => execSync(cmd, { cwd, timeout: 3000, encoding: 'utf8' }).trim();
+
+    // Check if git repo
+    try { run('git rev-parse --git-dir'); } catch { return null; }
+
+    // Resolve project ID: git remote → org/repo, fallback to directory name
+    let projectId = run('git rev-parse --show-toplevel').split('/').pop() || '';
+    try {
+      const remote = run('git remote get-url origin');
+      const match = remote.match(/[/:]([\w.-]+)\/([\w.-]+?)(?:\.git)?$/);
+      if (match) projectId = `${match[1]}/${match[2]}`;
+    } catch { /* no remote — use directory name */ }
+    const branch = run('git branch --show-current') || 'detached';
+
+    let stashCount = 0;
+    try { stashCount = run('git stash list').split('\n').filter(Boolean).length; } catch {}
+
+    let modified = 0, untracked = 0;
+    try {
+      const status = run('git status --porcelain');
+      for (const line of status.split('\n').filter(Boolean)) {
+        if (line.startsWith('??')) untracked++;
+        else modified++;
+      }
+    } catch {}
+
+    let ahead = 0, behind = 0;
+    try {
+      const counts = run('git rev-list --left-right --count HEAD...@{u}');
+      const [a, b] = counts.split('\t').map(Number);
+      ahead = a || 0;
+      behind = b || 0;
+    } catch {}
+
+    let lastCommitAge = '?';
+    let lastCommitColor = c.slate400;
+    try {
+      const epoch = parseInt(run('git log -1 --format=%ct'));
+      const seconds = Math.floor(Date.now() / 1000) - epoch;
+      if (seconds < 3600) {
+        lastCommitAge = `${Math.floor(seconds / 60)}m`;
+      } else if (seconds < 86400) {
+        lastCommitAge = `${Math.floor(seconds / 3600)}h`;
+      } else {
+        lastCommitAge = `${Math.floor(seconds / 86400)}d`;
+      }
+      lastCommitColor = ageColor(lastCommitAge);
+    } catch {}
+
+    return { projectId, branch, stashCount, modified, untracked, ahead, behind, lastCommitAge, lastCommitColor };
+  } catch {
+    return null;
+  }
+}
+
+// ── Rendering ──────────────────────────────────────────────────────────────
+
+function formatNumber(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
+  return String(n);
+}
+
+function contextBar(pct: number, width: number): string {
+  const filled = Math.round((pct / 100) * width);
+  let bar = '';
+  for (let i = 0; i < width; i++) {
+    if (i < filled) {
+      const ratio = i / width;
+      if (ratio < 0.4) bar += `${c.success}⛁`;
+      else if (ratio < 0.6) bar += `${c.accent}⛁`;
+      else if (ratio < 0.8) bar += `${c.warning}⛁`;
+      else bar += `${c.error}⛁`;
+    } else {
+      bar += `${c.barBg} ${c.reset}`;
+    }
+  }
+  return bar + c.reset;
+}
+
+function separator(width: number): string {
+  return `  ${c.border}${'─'.repeat(Math.min(width - 4, 72))}${c.reset}`;
+}
+
+interface Heartbeat {
+  effort: string;
+  intent: string;
+  confidence: string;
+  totalMs: number;
+  memoryDelivered: number;
+  stale: boolean;
+}
+
+function getHeartbeat(): Heartbeat {
+  try {
+    const data = JSON.parse(readFileSync('/tmp/gmtr-classification-savings.json', 'utf8'));
+    const age = Date.now() - (data.timestamp || 0);
+    const stale = age > 300_000;
+    const st = data.stage_timing || {};
+    return {
+      effort: data.effort || '',
+      intent: data.intent || '',
+      confidence: data.confidence ? `${Math.round(data.confidence * 100)}%` : '',
+      totalMs: st.total_ms || data.qwen_time_ms || 0,
+      memoryDelivered: data.memory_delivered || 0,
+      stale,
+    };
+  } catch {
+    return { effort: '', intent: '', confidence: '', totalMs: 0, memoryDelivered: 0, stale: true };
+  }
+}
+
+function render(input: CCInput, gmtr: GramatrStats | null, git: GitInfo | null): string {
+  const lines: string[] = [];
+  const termWidth = parseInt(process.env.COLUMNS || '80', 10);
+  const barWidth = Math.min(termWidth - 20, 55);
+  const version = gmtr?.server_version ? `v${gmtr.server_version}` : '';
+  const statusIcon = gmtr ? `${c.success}●${c.reset}` : `${c.error}○${c.reset}`;
+  const hb = getHeartbeat();
+
+  // ── LINE 1: BRAND + HEARTBEAT ──
+  let heartbeatText = '';
+  if (!hb.stale && hb.effort) {
+    heartbeatText = `${c.text}${hb.effort}/${hb.intent}${c.reset} ${c.accent}${hb.confidence}${c.reset} ${c.textMuted}${hb.totalMs}ms${c.reset}`;
+    if (hb.memoryDelivered > 0) {
+      heartbeatText += ` ${c.success}◇${hb.memoryDelivered} memories${c.reset}`;
+    }
+  }
+  const brandLine = `  ${c.border}──${c.reset} ${statusIcon} ` +
+    `${c.primary}grāmatr${c.reset} ` +
+    `${c.textMuted}${version}${c.reset}` +
+    (heartbeatText ? ` ${c.border}│${c.reset} ${heartbeatText}` : '') +
+    ` ${c.border}│${c.reset} ${c.textMuted}gramatr.com${c.reset}`;
+  lines.push(brandLine);
+
+  // ── LINE 2: CONTEXT ──
+  const ctxPct = input.context_window?.used_percentage || 0;
+  lines.push(separator(termWidth));
+  lines.push(`  ${c.accent}◉${c.reset} ${c.textMuted}CONTEXT:${c.reset} ${contextBar(ctxPct, barWidth)} ${c.text}${Math.round(ctxPct)}%${c.reset}`);
+
+  // ── LINE 3: PROJECT ──
+  if (git) {
+    lines.push(separator(termWidth));
+    lines.push(
+      `  ${c.primary}◈${c.reset} ${c.text}${git.projectId}${c.reset}` +
+      ` ${c.border}│${c.reset} ${c.accent}${git.branch}${c.reset}`
+    );
+  }
+
+  // ── LINE 5: GRAMATR INTELLIGENCE ──
+  if (gmtr) {
+    lines.push(separator(termWidth));
+    const cl = gmtr.classifier;
+    const level = cl.level > 0 ? `L${cl.level}` : '—';
+    const savedWeek = formatNumber(gmtr.tokens_saved_7d || 0);
+    const savedTotal = formatNumber(gmtr.tokens_saved_total || 0);
+    lines.push(
+      `  ${c.primary}◎${c.reset}` +
+      ` ${c.accent}⬢${formatNumber(gmtr.entity_count)}${c.reset}${c.textMuted} entities${c.reset}` +
+      ` ${c.border}│${c.reset} ${c.accent}◇${formatNumber(gmtr.observation_count)}${c.reset}${c.textMuted} obs${c.reset}` +
+      ` ${c.border}│${c.reset} ${c.primary}${level}${c.reset}` +
+      ` ${c.border}│${c.reset} ${c.textMuted}saved:${c.reset} ${c.success}${savedWeek}/wk${c.reset} ${c.text}${savedTotal}/all${c.reset}`
+    );
+  }
+
+  lines.push(separator(termWidth));
+  return lines.join('\n');
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+async function main() {
+  // Read CC JSON from stdin
+  let input: CCInput = {};
+  try {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(Buffer.from(chunk));
+    }
+    const raw = Buffer.concat(chunks).toString('utf8');
+    if (raw.trim()) input = JSON.parse(raw);
+  } catch { /* no stdin or bad JSON */ }
+
+  const cwd = input.workspace?.current_dir || input.cwd || process.cwd();
+
+  // Fetch gramatr stats
+  const gmtr = await fetchGramatrStats();
+
+  // Git is sync (fast, <100ms)
+  const git = getGitInfo(cwd);
+
+  // Render and output
+  const output = render(input, gmtr, git);
+  process.stdout.write(output + '\n');
+}
+
+main().catch(() => {
+  // Never crash — output minimal fallback
+  process.stdout.write(`  gramatr │ status unavailable\n`);
+});