meter-ai 0.2.0 → 0.3.0

package/src/commands/wrap.ts

@@ -0,0 +1,235 @@
+import { PtyWrapper } from '../pty/wrapper.js'
+import { readConfig } from '../storage/config-store.js'
+import { openDb, insertTask } from '../storage/db.js'
+import { runEstimationPipeline } from '../estimation/pipeline.js'
+import { injectStatusBar, renderStatusBar } from '../ui/statusbar.js'
+import { renderNotification } from '../ui/notification.js'
+import { waitForKeypress } from '../ui/keypress.js'
+import { parseTokensFromOutput, estimateInputTokens } from '../tracking/tokens.js'
+import { fetchPlanUsage, formatResetCountdown } from '../tracking/plan-usage.js'
+import { readCredentials, watchCredentials } from '../auth/credentials.js'
+import { calculateStatusBarLines } from '../pty/resize.js'
+import {
+  CONFIG_PATH, HISTORY_DB_PATH, CLAUDE_CREDENTIALS_PATH
+} from '../constants.js'
+import { execSync } from 'child_process'
+import { createHash } from 'crypto'
+import type { StatusBarState } from '../ui/statusbar.js'
+import type { Complexity } from '../types.js'
+
+export async function runWrap(args: string[]): Promise<void> {
+  const trueBinary = args[0]
+  const agentArgs = args.slice(1)
+  const prompt = agentArgs.join(' ')
+
+  if (!trueBinary) {
+    console.error('[meter] wrap: missing binary argument')
+    process.exit(1)
+  }
+
+  const config = await readConfig(CONFIG_PATH)
+  if (!config) {
+    // No config — run agent directly without wrapping
+    const w = new PtyWrapper()
+    w.spawn(trueBinary, agentArgs, process.env as NodeJS.ProcessEnv)
+    await new Promise<void>(resolve => w.on('exit', () => resolve()))
+    return
+  }
+
+  const db = await openDb(HISTORY_DB_PATH)
+
+  // Get repo identifier
+  let repo: string | null = null
+  try { repo = execSync('git remote get-url origin 2>/dev/null').toString().trim() } catch {}
+  if (!repo) { try { repo = process.cwd() } catch {} }
+
+  // Get repo file count for estimation
+  let repoFileCount = 100
+  try { repoFileCount = parseInt(execSync('git ls-files 2>/dev/null | wc -l').toString().trim(), 10) || 100 } catch {}
+
+  // Run estimation (non-blocking display)
+  const estimation = await runEstimationPipeline({
+    prompt,
+    repoFileCount,
+    db,
+    repo,
+    config: config.estimation,
+  })
+
+  // Fetch initial plan usage if Plan Mode
+  let planUsage: Awaited<ReturnType<typeof fetchPlanUsage>> = null
+  let creds: Awaited<ReturnType<typeof readCredentials>> = null
+  if (config.mode === 'plan' && config.org_id) {
+    creds = await readCredentials(CLAUDE_CREDENTIALS_PATH)
+    if (creds) planUsage = await fetchPlanUsage(config.org_id, creds)
+  }
+
+  // State for status bar
+  const state: StatusBarState = {
+    model: config.models.claude_chain[0],
+    estimatedCost: estimation.estimated_cost,
+    complexity: estimation.complexity as Complexity,
+    mode: config.mode,
+    elapsedCost: 0,
+    budgetUsd: config.budget.per_task_usd,
+    windowPct: planUsage?.five_hour_pct ?? null,
+    windowResetIn: planUsage ? formatResetCountdown(planUsage.five_hour_reset_at) : null,
+  }
+
+  // Spawn agent in PTY — declare BEFORE updateBar so closure can reference it safely
+  const wrapper = new PtyWrapper()
+  let outputBuffer = ''
+  let thresholdNotified = false
+  let modelSwitched = 0
+
+  // Status bar update function — adapts to PTY vs fallback mode
+  let statusBarShown = false
+  const updateBar = () => {
+    if (wrapper.isInAlternateScreen) return
+    const content = renderStatusBar(state)
+
+    if (wrapper.usingFallback) {
+      // Fallback mode: only show status bar once as a header, then on threshold
+      if (!statusBarShown) {
+        process.stdout.write(content + '\n')
+        statusBarShown = true
+      }
+    } else {
+      // PTY mode: inject at fixed position via escape codes
+      const N = calculateStatusBarLines(content.replace(/\x1b\[[^m]*m/g, '').length, process.stdout.columns ?? 80)
+      injectStatusBar(content, N)
+    }
+  }
+
+  // Watch for credential refresh
+  if (config.mode === 'plan') {
+    watchCredentials(CLAUDE_CREDENTIALS_PATH, async (newCreds) => {
+      if (newCreds) creds = newCreds
+    })
+  }
+
+  // Plan usage polling (15s during active task)
+  let pollInterval: NodeJS.Timeout | null = null
+  if (config.mode === 'plan' && config.org_id && creds) {
+    pollInterval = setInterval(async () => {
+      if (!creds || !config.org_id) return
+      const usage = await fetchPlanUsage(config.org_id, creds)
+      if (usage) {
+        state.windowPct = usage.five_hour_pct
+        state.windowResetIn = formatResetCountdown(usage.five_hour_reset_at)
+        updateBar()
+      }
+    }, 15_000)
+  }
+
+  // Per-prompt estimation: when user submits a new prompt inside the interactive
+  // session, re-run the estimation pipeline and update the status bar
+  let lastPrompt = prompt // initial prompt from CLI args
+  wrapper.on('input', async (newPrompt: string) => {
+    lastPrompt = newPrompt
+    const newEstimation = await runEstimationPipeline({
+      prompt: newPrompt,
+      repoFileCount,
+      db,
+      repo,
+      config: config.estimation,
+    })
+    state.estimatedCost = newEstimation.estimated_cost
+    state.complexity = newEstimation.complexity as Complexity
+    // Reset elapsed cost for the new prompt
+    state.elapsedCost = 0
+    thresholdNotified = false
+    statusBarShown = false // allow fallback mode to re-print
+    updateBar()
+  })
+
+  wrapper.on('data', (chunk: string) => {
+    outputBuffer += chunk
+    // Rough running cost estimate from output volume
+    state.elapsedCost = (state.elapsedCost ?? 0) + (chunk.length / 4 / 1_000_000) * 15
+    updateBar()
+
+    // Check threshold
+    if (!thresholdNotified) {
+      const exceeded = config.mode === 'api'
+        ? ((state.elapsedCost ?? 0) / config.budget.per_task_usd) * 100 >= config.budget.threshold_pct
+        : (state.windowPct ?? 0) >= config.plan.window_threshold_pct
+
+      if (exceeded) {
+        thresholdNotified = true
+        handleThreshold()
+      }
+    }
+  })
+
+  async function handleThreshold() {
+    // config is guaranteed non-null here (we returned early above if null)
+    const cfg = config!
+    const nextModel = cfg.models.claude_chain[1] ?? null
+    const notification = renderNotification({
+      mode: cfg.mode,
+      thresholdPct: cfg.mode === 'api' ? cfg.budget.threshold_pct : cfg.plan.window_threshold_pct,
+      elapsedCost: state.elapsedCost,
+      budgetUsd: cfg.budget.per_task_usd,
+      windowPct: state.windowPct,
+      nextModel,
+    })
+
+    process.stdout.write('\n' + notification + '\n')
+
+    const action = await waitForKeypress(['s', 'd', 'c'], 0)
+
+    if (action === 'c') {
+      wrapper.kill()
+    } else if (action === 's' && nextModel) {
+      process.stdout.write(`\n↻ restarting with ${nextModel}  (context will reset — press c within 5s to cancel)\n`)
+      const cancel = await waitForKeypress(['c'], 5_000)
+      if (cancel !== 'c') {
+        wrapper.kill()
+        state.model = nextModel
+        modelSwitched = 1
+        wrapper.spawn(trueBinary, [`--model`, nextModel, ...agentArgs.slice(1)], process.env as NodeJS.ProcessEnv)
+      }
+    }
+    // 'd' = dismiss, do nothing
+  }
+
+  const taskStart = Date.now()
+
+  // Reserve status bar line and spawn
+  process.stdout.write('\n')
+  updateBar()
+  wrapper.spawn(trueBinary, agentArgs, process.env as NodeJS.ProcessEnv)
+
+  const exitCode = await new Promise<number>(resolve => {
+    wrapper.on('exit', (code: number) => resolve(code))
+  })
+
+  if (pollInterval) clearInterval(pollInterval)
+
+  // Parse final token counts
+  const tokens = parseTokensFromOutput(outputBuffer)
+  const finalPrompt = lastPrompt || prompt
+  const promptHash = createHash('sha256').update(finalPrompt.toLowerCase().trim()).digest('hex').slice(0, 16)
+
+  insertTask(db, {
+    created_at: taskStart,
+    repo,
+    prompt_hash: promptHash,
+    prompt_text: finalPrompt,
+    model: state.model,
+    complexity: estimation.complexity as Complexity,
+    est_layer: estimation.layer_used,
+    est_cost: estimation.estimated_cost,
+    actual_tokens_in: tokens?.input ?? estimateInputTokens(prompt.length),
+    actual_tokens_out: tokens?.output ?? null,
+    actual_cost: config.mode === 'api' ? (state.elapsedCost ?? null) : null,
+    window_pct_start: planUsage?.five_hour_pct ?? null,
+    window_pct_end: state.windowPct,
+    model_switched: modelSwitched,
+    exit_code: exitCode,
+  })
+
+  db.close()
+  process.exit(exitCode)
+}

package/src/constants.ts

@@ -0,0 +1,52 @@
+import { homedir } from 'os'
+import { join } from 'path'
+
+export const METER_DIR = join(homedir(), '.meter')
+export const METER_BIN_DIR = join(METER_DIR, 'bin')
+export const CONFIG_PATH = join(METER_DIR, 'config.json')
+export const HISTORY_DB_PATH = join(METER_DIR, 'history.db')
+export const PRICING_PATH = join(METER_DIR, 'pricing.json')
+export const USAGE_CACHE_PATH = join(METER_DIR, 'cache', 'usage.json')
+export const SESSION_CACHE_PATH = join(METER_DIR, 'cache', 'session.json')
+export const ERRORS_LOG_PATH = join(METER_DIR, 'cache', 'errors.log')
+export const REPORTS_DIR = join(METER_DIR, 'reports')
+
+export const DEFAULT_CONFIG_VALUES = {
+  budget_per_task_usd: 0.50,
+  threshold_pct: 80,
+  window_threshold_pct: 80,
+  poll_interval_seconds: 60,
+  min_confidence_to_skip_llm: 0.85,
+  claude_chain: ['claude-opus-4-20250514', 'claude-sonnet-4-20250514', 'claude-haiku-4-20250307'],
+  llm_precheck_model: 'claude-haiku-4-20250307',
+}
+
+export const CLAUDE_USAGE_API = 'https://claude.ai/api/organizations'
+export const CLAUDE_BOOTSTRAP_API = 'https://claude.ai/api/bootstrap'
+export const CLAUDE_CREDENTIALS_PATH = join(homedir(), '.claude', '.credentials.json')
+export const CLAUDE_SETTINGS_PATH = join(homedir(), '.claude', 'settings.json')
+
+export const KEYWORD_WEIGHTS: Record<string, number> = {
+  'refactor entire': 0.9,
+  'rewrite': 0.85,
+  'migrate': 0.8,
+  'refactor': 0.7,
+  'implement': 0.6,
+  'add feature': 0.55,
+  'add tests': 0.5,
+  'add': 0.4,
+  'update': 0.35,
+  'fix': 0.3,
+  'debug': 0.3,
+  'change': 0.25,
+  'rename': 0.2,
+  'fix typo': 0.05,
+  'typo': 0.05,
+}
+
+export const COMPLEXITY_THRESHOLDS = {
+  low: 0.3,
+  medium: 0.55,
+  heavy: 0.75,
+  critical: 1.0,
+}

package/src/estimation/heuristics.ts

@@ -0,0 +1,36 @@
+import { KEYWORD_WEIGHTS, COMPLEXITY_THRESHOLDS } from '../constants.js'
+import type { Complexity, EstimationResult } from '../types.js'
+
+interface HeuristicInput {
+  prompt: string
+  repoFileCount: number
+}
+
+export function scoreHeuristics(input: HeuristicInput): Pick<EstimationResult, 'complexity' | 'confidence'> {
+  const lower = input.prompt.toLowerCase()
+
+  // Use the most-specific (longest) matching keyword to avoid over-counting
+  let keywordScore = 0.35
+  let bestMatchLen = 0
+  for (const [keyword, weight] of Object.entries(KEYWORD_WEIGHTS)) {
+    if (lower.includes(keyword) && keyword.length > bestMatchLen) {
+      bestMatchLen = keyword.length
+      keywordScore = weight
+    }
+  }
+
+  const sizeModifier = Math.min(input.repoFileCount / 500, 0.2)
+  const lengthModifier = lower.length > 60 ? 0.05 : 0
+  const rawScore = Math.min(keywordScore + sizeModifier + lengthModifier, 1.0)
+
+  // critical uses strict > so it is unreachable via capped rawScore;
+  // heavy is the practical maximum from heuristics alone
+  let complexity: Complexity = 'low'
+  if (rawScore > COMPLEXITY_THRESHOLDS.critical) complexity = 'critical'
+  else if (rawScore >= COMPLEXITY_THRESHOLDS.heavy) complexity = 'heavy'
+  else if (rawScore >= COMPLEXITY_THRESHOLDS.medium) complexity = 'medium'
+
+  const confidence = keywordScore >= 0.8 || keywordScore <= 0.1 ? 0.9 : 0.65
+
+  return { complexity, confidence }
+}

package/src/estimation/history-matcher.ts

@@ -0,0 +1,43 @@
+import type { DB } from '../storage/db.js'
+import type { EstimationResult, TaskRecord } from '../types.js'
+
+function trigramSimilarity(a: string, b: string): number {
+  const trigrams = (s: string): Set<string> => {
+    const set = new Set<string>()
+    const padded = `  ${s.toLowerCase()}  `
+    for (let i = 0; i < padded.length - 2; i++) {
+      set.add(padded.slice(i, i + 3))
+    }
+    return set
+  }
+
+  const ta = trigrams(a)
+  const tb = trigrams(b)
+  const intersection = [...ta].filter(t => tb.has(t)).length
+  const union = new Set([...ta, ...tb]).size
+  return union === 0 ? 0 : intersection / union
+}
+
+const MIN_SIMILARITY = 0.25
+const MIN_RUNS = 3
+
+export function matchHistory(
+  db: DB,
+  prompt: string,
+  repo: string | null
+): Pick<EstimationResult, 'estimated_cost' | 'layer_used'> | null {
+  const candidates = db.prepare(
+    'SELECT * FROM tasks WHERE repo = ? AND actual_cost IS NOT NULL ORDER BY created_at DESC LIMIT 100'
+  ).all(repo) as TaskRecord[]
+
+  const matches = candidates.filter(t =>
+    trigramSimilarity(t.prompt_text, prompt) >= MIN_SIMILARITY
+  )
+
+  if (matches.length < MIN_RUNS) return null
+
+  const costs = matches.map(t => t.actual_cost!).sort((a, b) => a - b)
+  const median = costs[Math.floor(costs.length / 2)]
+
+  return { estimated_cost: median, layer_used: 2 }
+}

package/src/estimation/llm-precheck.ts

@@ -0,0 +1,27 @@
+import Anthropic from '@anthropic-ai/sdk'
+import type { Complexity } from '../types.js'
+
+const VALID_COMPLEXITIES = new Set<Complexity>(['low', 'medium', 'heavy', 'critical'])
+
+export async function llmClassify(
+  prompt: string,
+  repoFileCount: number,
+  model: string
+): Promise<Complexity | null> {
+  try {
+    const client = new Anthropic()
+    const message = await client.messages.create({
+      model,
+      max_tokens: 10,
+      messages: [{
+        role: 'user',
+        content: `Classify this coding task complexity: low | medium | heavy | critical\nTask: "${prompt}"\nRepo: ${repoFileCount} files\nReply with exactly one word.`
+      }]
+    })
+
+    const text = (message.content[0] as { type: 'text'; text: string }).text.trim().toLowerCase() as Complexity
+    return VALID_COMPLEXITIES.has(text) ? text : null
+  } catch {
+    return null
+  }
+}

package/src/estimation/pipeline.ts

@@ -0,0 +1,67 @@
+import { scoreHeuristics } from './heuristics.js'
+import { matchHistory } from './history-matcher.js'
+import { llmClassify } from './llm-precheck.js'
+import type { DB } from '../storage/db.js'
+import type { EstimationResult } from '../types.js'
+
+const COST_BY_COMPLEXITY = { low: 0.02, medium: 0.09, heavy: 0.38, critical: 0.80 }
+
+interface PipelineInput {
+  prompt: string
+  repoFileCount: number
+  db: DB | null
+  repo: string | null
+  config: {
+    use_llm_precheck: boolean
+    llm_precheck_model: string
+    min_confidence_to_skip_llm: number
+  }
+}
+
+export async function runEstimationPipeline(input: PipelineInput): Promise<EstimationResult> {
+  // Layer 1: heuristics
+  const heuristic = scoreHeuristics({ prompt: input.prompt, repoFileCount: input.repoFileCount })
+
+  if (heuristic.confidence >= input.config.min_confidence_to_skip_llm) {
+    return {
+      complexity: heuristic.complexity,
+      confidence: heuristic.confidence,
+      estimated_cost: COST_BY_COMPLEXITY[heuristic.complexity],
+      layer_used: 1
+    }
+  }
+
+  // Layer 2: historical baseline
+  if (input.db && input.repo) {
+    const historical = matchHistory(input.db, input.prompt, input.repo)
+    if (historical?.estimated_cost !== undefined) {
+      return {
+        complexity: heuristic.complexity,
+        confidence: 0.8,
+        estimated_cost: historical.estimated_cost,
+        layer_used: 2
+      }
+    }
+  }
+
+  // Layer 3: LLM pre-call
+  if (input.config.use_llm_precheck) {
+    const llmResult = await llmClassify(input.prompt, input.repoFileCount, input.config.llm_precheck_model)
+    if (llmResult) {
+      return {
+        complexity: llmResult,
+        confidence: 0.87,
+        estimated_cost: COST_BY_COMPLEXITY[llmResult],
+        layer_used: 3
+      }
+    }
+  }
+
+  // Fallback: use heuristic
+  return {
+    complexity: heuristic.complexity,
+    confidence: heuristic.confidence,
+    estimated_cost: COST_BY_COMPLEXITY[heuristic.complexity],
+    layer_used: 1
+  }
+}

package/src/hooks/on-prompt.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * meter — UserPromptSubmit hook
+ *
+ * Runs when user submits a prompt in Claude Code.
+ * Executes the estimation pipeline and writes result to ~/.meter/cache/latest-estimate.json
+ * The statusline command reads this file to display the estimate.
+ */
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const METER_DIR = path.join(os.homedir(), '.meter');
+const CACHE_DIR = path.join(METER_DIR, 'cache');
+const ESTIMATE_FILE = path.join(CACHE_DIR, 'latest-estimate.json');
+const CONFIG_FILE = path.join(METER_DIR, 'config.json');
+
+// Keyword weights for heuristic scoring
+const KEYWORD_WEIGHTS = {
+  'refactor entire': 0.9, 'rewrite': 0.85, 'migrate': 0.8,
+  'refactor': 0.7, 'implement': 0.6, 'add feature': 0.55,
+  'add tests': 0.5, 'add': 0.4, 'update': 0.35,
+  'fix': 0.3, 'debug': 0.3, 'change': 0.25,
+  'rename': 0.2, 'fix typo': 0.05, 'typo': 0.05,
+};
+
+const COST_BY_COMPLEXITY = { low: 0.02, medium: 0.09, heavy: 0.38, critical: 0.80 };
+
+function scorePrompt(prompt) {
+  const lower = prompt.toLowerCase();
+
+  let keywordScore = 0.35;
+  // Longest match wins
+  const sorted = Object.entries(KEYWORD_WEIGHTS).sort((a, b) => b[0].length - a[0].length);
+  for (const [keyword, weight] of sorted) {
+    if (lower.includes(keyword)) {
+      keywordScore = Math.max(keywordScore, weight);
+      break;
+    }
+  }
+
+  // Repo file count
+  let fileCount = 100;
+  try { fileCount = parseInt(execSync('git ls-files 2>/dev/null | wc -l').toString().trim(), 10) || 100; } catch {}
+
+  const sizeModifier = Math.min(fileCount / 500, 0.2);
+  const rawScore = Math.min(keywordScore + sizeModifier, 1.0);
+
+  let complexity = 'low';
+  if (rawScore >= 0.75) complexity = 'heavy';
+  else if (rawScore >= 0.55) complexity = 'medium';
+
+  const cost = COST_BY_COMPLEXITY[complexity];
+  return { complexity, cost, prompt: prompt.slice(0, 80) };
+}
+
+try {
+  // Read prompt from stdin (Claude Code pipes it)
+  const input = fs.readFileSync(0, 'utf-8').trim();
+  let prompt = '';
+
+  try {
+    const parsed = JSON.parse(input);
+    prompt = parsed.prompt || parsed.message || input;
+  } catch {
+    prompt = input;
+  }
+
+  if (!prompt) process.exit(0);
+
+  const estimate = scorePrompt(prompt);
+  estimate.timestamp = Date.now();
+
+  // Read config for mode
+  try {
+    const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    estimate.mode = config.mode;
+    estimate.model = config.models?.claude_chain?.[0] || 'unknown';
+    estimate.budget = config.budget?.per_task_usd || 0.50;
+  } catch {
+    estimate.mode = 'api';
+    estimate.model = 'unknown';
+    estimate.budget = 0.50;
+  }
+
+  fs.mkdirSync(CACHE_DIR, { recursive: true });
+  fs.writeFileSync(ESTIMATE_FILE, JSON.stringify(estimate));
+} catch (e) {
+  // Never block Claude Code — fail silently
+  process.exit(0);
+}

package/src/hooks/statusline.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * meter — Statusline command for Claude Code
+ *
+ * Reads the latest estimation from ~/.meter/cache/latest-estimate.json
+ * and outputs a formatted status string for Claude Code's bottom bar.
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const ESTIMATE_FILE = path.join(os.homedir(), '.meter', 'cache', 'latest-estimate.json');
+
+try {
+  if (!fs.existsSync(ESTIMATE_FILE)) {
+    process.stdout.write('meter: ready');
+    process.exit(0);
+  }
+
+  const data = JSON.parse(fs.readFileSync(ESTIMATE_FILE, 'utf-8'));
+  const age = Date.now() - (data.timestamp || 0);
+
+  // If estimate is older than 10 minutes, show stale indicator
+  if (age > 600_000) {
+    process.stdout.write('meter: idle');
+    process.exit(0);
+  }
+
+  const cost = data.cost != null ? `~$${data.cost.toFixed(2)}` : '?';
+  const complexity = data.complexity || '?';
+  const prompt = (data.prompt || '').slice(0, 30);
+
+  process.stdout.write(`meter ${cost} ${complexity} │ ${prompt}`);
+} catch {
+  process.stdout.write('meter: ready');
+}

package/src/index.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { runInit } from './commands/init.js'
+import { runStatus } from './commands/status.js'
+import { runReport } from './commands/report.js'
+import { runHistory } from './commands/history.js'
+import { runConfig } from './commands/config.js'
+import { runUninstall } from './commands/uninstall.js'
+import { runWrap } from './commands/wrap.js'
+import { METER_DIR } from './constants.js'
+
+const [,, command, ...args] = process.argv
+
+const commands: Record<string, () => Promise<void>> = {
+  init: () => runInit({ meterDir: METER_DIR }),
+  status: runStatus,
+  report: runReport,
+  history: () => runHistory(args),
+  config: () => runConfig(args),
+  uninstall: runUninstall,
+  wrap: () => runWrap(args),
+}
+
+async function main() {
+  if (!command || command === '--help' || command === '-h') {
+    console.log(`
+◆ meter — intelligent wrapper for Claude Code
+
+  meter init        Set up PATH shim and config
+  meter status      Show current mode, usage, and config
+  meter report      Weekly digest of usage and costs
+  meter history     Browse past task records
+  meter config      View and set configuration values
+  meter uninstall   Remove meter completely
+`)
+    return
+  }
+
+  const handler = commands[command]
+  if (!handler) {
+    console.error(`Unknown command: ${command}`)
+    process.exit(1)
+  }
+
+  await handler()
+}
+
+main().catch(err => {
+  console.error('[meter error]', err.message)
+  process.exit(1)
+})

package/src/pty/resize.ts

@@ -0,0 +1,15 @@
+export interface TerminalSize {
+  cols: number
+  rows: number
+}
+
+export function getTerminalSize(): TerminalSize {
+  return {
+    cols: process.stdout.columns ?? 80,
+    rows: process.stdout.rows ?? 24,
+  }
+}
+
+export function calculateStatusBarLines(statusBarCharCount: number, cols: number): number {
+  return Math.ceil(statusBarCharCount / cols)
+}

package/src/pty/screen.ts

@@ -0,0 +1,15 @@
+const ENTER_ALT_SCREEN = '\x1b[?1049h'
+const EXIT_ALT_SCREEN = '\x1b[?1049l'
+
+export class AlternateScreenTracker {
+  private _isActive = false
+
+  get isActive(): boolean {
+    return this._isActive
+  }
+
+  process(chunk: string): void {
+    if (chunk.includes(ENTER_ALT_SCREEN)) this._isActive = true
+    if (chunk.includes(EXIT_ALT_SCREEN)) this._isActive = false
+  }
+}