@gramatr/client 0.5.1

package/bin/lib/config.ts

@@ -0,0 +1,57 @@
+/**
+ * gramatr client config resolver (statusline refactor, #495).
+ *
+ * Single-purpose helper that returns the server URL + auth token with
+ * NO reads of ~/.claude* or ~/gmtr-client/settings.json. This is the
+ * statusline-specific config path; the richer installer auth lives in
+ * core/auth.ts for a reason — this file must stay small and side-effect-free
+ * so it can be loaded in a 2s shim without touching disk more than once.
+ *
+ * Resolution:
+ *   URL   — GMTR_URL → ~/.gmtr.json.url → https://api.gramatr.com
+ *   Token — GMTR_TOKEN → AIOS_MCP_TOKEN → ~/.gmtr.json.token → null
+ */
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+export interface GramatrConfig {
+  url: string;
+  token: string | null;
+}
+
+const DEFAULT_URL = 'https://api.gramatr.com';
+
+function getHome(): string {
+  return process.env.HOME || process.env.USERPROFILE || homedir();
+}
+
+function readGmtrJson(): Record<string, any> | null {
+  const path = join(getHome(), '.gmtr.json');
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function getGramatrConfig(): GramatrConfig {
+  const json = readGmtrJson();
+
+  const rawUrl =
+    process.env.GMTR_URL ||
+    (typeof json?.url === 'string' && json.url) ||
+    DEFAULT_URL;
+  // GMTR_URL is conventionally the MCP endpoint (e.g. https://api.gramatr.com/mcp).
+  // REST calls need the API base — strip a trailing /mcp segment.
+  const url = (rawUrl as string).replace(/\/mcp\/?$/, '');
+
+  const token =
+    process.env.GMTR_TOKEN ||
+    process.env.AIOS_MCP_TOKEN ||
+    (typeof json?.token === 'string' && json.token) ||
+    null;
+
+  return { url: url as string, token };
+}

package/bin/lib/git.ts

@@ -0,0 +1,111 @@
+/**
+ * Git state collection for the statusline client (#495).
+ *
+ * Three subprocess calls, not seven:
+ *   1. git rev-parse --show-toplevel   — is this even a repo?
+ *   2. git remote get-url origin       — project_id derivation
+ *   3. git status --porcelain=v2 --branch   — branch + file counts in one call
+ *
+ * A fourth call (git log -1 --format=%cr) runs only when the porcelain output
+ * indicates we have commits, keeping the empty-repo path clean.
+ *
+ * All functions are pure in terms of parseable input → output (parsePorcelain,
+ * parseProjectId) so they can be tested without spawning git.
+ */
+import { execSync } from 'child_process';
+
+export interface GitStateFields {
+  branch: string;
+  ahead: number;
+  behind: number;
+  modified: number;
+  untracked: number;
+  stash: number;
+  last_commit_age: string;
+}
+
+export interface GitInfo {
+  projectId: string;
+  state: GitStateFields;
+}
+
+export function parseProjectId(remoteUrl: string): string {
+  if (!remoteUrl) return '';
+  // Handle both https://github.com/org/repo(.git) and git@github.com:org/repo(.git)
+  const cleaned = remoteUrl.trim().replace(/\.git$/, '');
+  const sshMatch = cleaned.match(/[:/]([^:/]+\/[^:/]+)$/);
+  if (sshMatch) return sshMatch[1];
+  return cleaned;
+}
+
+/**
+ * Parse `git status --porcelain=v2 --branch` output.
+ *
+ * Header lines start with '#'. Entry lines start with '1', '2', 'u', or '?'.
+ * We count:
+ *   branch from `# branch.head <name>`
+ *   ahead/behind from `# branch.ab +N -M`
+ *   modified from '1 ', '2 ', 'u ' entries
+ *   untracked from '? ' entries
+ */
+export function parsePorcelain(out: string): GitStateFields {
+  const state: GitStateFields = {
+    branch: '',
+    ahead: 0,
+    behind: 0,
+    modified: 0,
+    untracked: 0,
+    stash: 0,
+    last_commit_age: '',
+  };
+
+  for (const line of out.split('\n')) {
+    if (!line) continue;
+    if (line.startsWith('# branch.head ')) {
+      state.branch = line.slice('# branch.head '.length).trim();
+    } else if (line.startsWith('# branch.ab ')) {
+      const parts = line.slice('# branch.ab '.length).trim().split(/\s+/);
+      for (const p of parts) {
+        if (p.startsWith('+')) state.ahead = parseInt(p.slice(1), 10) || 0;
+        else if (p.startsWith('-')) state.behind = parseInt(p.slice(1), 10) || 0;
+      }
+    } else if (line[0] === '1' || line[0] === '2' || line[0] === 'u') {
+      state.modified += 1;
+    } else if (line[0] === '?') {
+      state.untracked += 1;
+    }
+  }
+
+  return state;
+}
+
+function execOrNull(cmd: string, cwd: string): string | null {
+  try {
+    return execSync(cmd, { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+  } catch {
+    return null;
+  }
+}
+
+export function getGitState(cwd: string): GitInfo | null {
+  const root = execOrNull('git rev-parse --show-toplevel', cwd);
+  if (!root) return null;
+
+  const remote = execOrNull('git remote get-url origin', cwd) ?? '';
+  const porcelain = execOrNull('git status --porcelain=v2 --branch', cwd) ?? '';
+  const state = parsePorcelain(porcelain);
+
+  // Stash count — cheap single call; returns empty on no stashes
+  const stashRaw = execOrNull('git stash list', cwd) ?? '';
+  state.stash = stashRaw ? stashRaw.split('\n').filter(Boolean).length : 0;
+
+  // Last commit age — only meaningful if branch has commits
+  if (state.branch && state.branch !== '(detached)') {
+    const age = execOrNull('git log -1 --format=%cr', cwd);
+    if (age) state.last_commit_age = age.trim();
+  }
+
+  const projectId = parseProjectId(remote) || 'local';
+
+  return { projectId, state };
+}

package/bin/lib/stdin.ts

@@ -0,0 +1,53 @@
+/**
+ * Minimal stdin reader for the statusline shim (#495).
+ *
+ * Claude Code pipes a JSON blob to statusline commands. We read it with a
+ * hard cap + timeout so a broken pipe never hangs the render.
+ */
+
+export interface CCInput {
+  session_id?: string;
+  cwd?: string;
+  workspace?: { current_dir?: string };
+}
+
+const MAX_STDIN_BYTES = 64 * 1024;
+const STDIN_TIMEOUT_MS = 500;
+
+export async function readStdin(): Promise<CCInput> {
+  // If stdin is a TTY there's nothing to read — return empty immediately.
+  if (process.stdin.isTTY) return {};
+
+  return new Promise((resolve) => {
+    let data = '';
+    let settled = false;
+
+    const finish = (input: CCInput) => {
+      if (settled) return;
+      settled = true;
+      resolve(input);
+    };
+
+    const timer = setTimeout(() => finish({}), STDIN_TIMEOUT_MS);
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk: string) => {
+      data += chunk;
+      if (data.length > MAX_STDIN_BYTES) {
+        data = data.slice(0, MAX_STDIN_BYTES);
+      }
+    });
+    process.stdin.on('end', () => {
+      clearTimeout(timer);
+      try {
+        finish(data.trim() ? (JSON.parse(data) as CCInput) : {});
+      } catch {
+        finish({});
+      }
+    });
+    process.stdin.on('error', () => {
+      clearTimeout(timer);
+      finish({});
+    });
+  });
+}

package/bin/logout.ts

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * gramatr logout — Clear stored gramatr credentials (issue #484).
+ *
+ * Removes ~/.gmtr.json. With --keep-backup, renames it to
+ * ~/.gmtr.json.bak.<timestamp> instead of deleting.
+ *
+ * Not-logged-in is not an error: exits 0 with a clean message.
+ */
+
+import { existsSync, renameSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+function gmtrJsonPath(): string {
+  return join(process.env.HOME || process.env.USERPROFILE || homedir(), ".gmtr.json");
+}
+
+function log(msg: string = ""): void {
+  process.stdout.write(`${msg}\n`);
+}
+
+function parseArgs(argv: string[]): { keepBackup: boolean; help: boolean } {
+  let keepBackup = false;
+  let help = false;
+  for (const a of argv) {
+    if (a === "--keep-backup") keepBackup = true;
+    else if (a === "--help" || a === "-h") help = true;
+  }
+  return { keepBackup, help };
+}
+
+function showHelp(): void {
+  log(`gramatr logout — Clear stored gramatr credentials
+
+Usage:
+  gramatr logout                Delete ~/.gmtr.json
+  gramatr logout --keep-backup  Rename to ~/.gmtr.json.bak.<timestamp> instead`);
+}
+
+export function main(argv: string[] = process.argv.slice(2)): number {
+  const opts = parseArgs(argv);
+  if (opts.help) {
+    showHelp();
+    return 0;
+  }
+
+  if (!existsSync(gmtrJsonPath())) {
+    log("Not logged in.");
+    return 0;
+  }
+
+  if (opts.keepBackup) {
+    const backup = `${gmtrJsonPath()}.bak.${Date.now()}`;
+    renameSync(gmtrJsonPath(), backup);
+    log(`Logged out. Token moved to ${backup}.`);
+    return 0;
+  }
+
+  unlinkSync(gmtrJsonPath());
+  log(`Logged out. Token removed from ${gmtrJsonPath()}.`);
+  return 0;
+}
+
+const isDirect = (() => {
+  try {
+    const invoked = process.argv[1] || "";
+    return invoked.endsWith("logout.ts") || invoked.endsWith("logout.js");
+  } catch {
+    return false;
+  }
+})();
+
+if (isDirect) {
+  process.exit(main());
+}

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,81 @@
+#!/usr/bin/env node
+/**
+ * gramatr status line — thin client shim (#495).
+ *
+ * The server owns composition and rendering. This file is a pipe:
+ *   1. Read stdin (Claude Code JSON — session_id, cwd)
+ *   2. Collect git state (3 subprocess calls, see lib/git.ts)
+ *   3. POST /api/v1/statusline/render with render_as=native
+ *   4. Write the server's rendered string to stdout
+ *
+ * Anti-criteria (enforced by regression grep in CI — see
+ * lib/__tests__/statusline-anti-criteria.test.ts for the tombstone list):
+ *   - No temp-file reads or writes
+ *   - No Claude config reads
+ *   - No legacy client settings reads
+ *   - No display of Claude-owned data (context window, model name)
+ *   - No local caches (statusline is a view, not a database)
+ *   - One and only one network call
+ *
+ * Failure modes are FIRST-CLASS:
+ *   - not a repo → silent (exit 0, nothing written)
+ *   - no token → authentication prompt
+ *   - offline/timeout/non-2xx → offline indicator
+ */
+
+import { getGitState } from './lib/git.js';
+import { getGramatrConfig } from './lib/config.js';
+import { readStdin } from './lib/stdin.js';
+
+const CLIENT_TIMEOUT_MS = 2000;
+
+type Size = 'small' | 'medium' | 'large';
+
+async function main(): Promise<void> {
+  const input = await readStdin();
+  const cwd = input.workspace?.current_dir || input.cwd || process.cwd();
+
+  const git = getGitState(cwd);
+  if (!git) {
+    // Not inside a git repo — render nothing, exit clean.
+    return;
+  }
+
+  const { url, token } = getGramatrConfig();
+  if (!token) {
+    process.stdout.write('  ● grāmatr │ not authenticated — run npx gramatr login\n');
+    return;
+  }
+
+  const envSize = process.env.GMTR_STATUSLINE_SIZE;
+  const size: Size =
+    envSize === 'small' || envSize === 'medium' || envSize === 'large' ? envSize : 'medium';
+
+  try {
+    const resp = await fetch(`${url}/api/v1/statusline/render`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        project_id: git.projectId,
+        session_id: input.session_id || 'no-session',
+        size,
+        render_as: 'native',
+        git_state: git.state,
+      }),
+      signal: AbortSignal.timeout(CLIENT_TIMEOUT_MS),
+    });
+
+    if (!resp.ok) throw new Error(`status ${resp.status}`);
+    const data = (await resp.json()) as { rendered?: string };
+    process.stdout.write(data.rendered ?? '  ● grāmatr │ offline\n');
+  } catch {
+    process.stdout.write('  ● grāmatr │ offline\n');
+  }
+}
+
+main().catch(() => {
+  process.stdout.write('  ● grāmatr │ error\n');
+});

package/bin/uninstall.ts

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+/**
+ * gramatr uninstaller — reverses install, restores configs to pre-gramatr state.
+ *
+ * Usage:
+ *   bun uninstall.ts              # Interactive — confirms each step
+ *   bun uninstall.ts --yes        # Non-interactive — uninstall everything
+ *   bun uninstall.ts --keep-auth  # Keep ~/.gmtr.json (preserve login)
+ *   npx tsx uninstall.ts          # Without bun
+ */
+
+import { existsSync, readFileSync, writeFileSync, rmSync, readdirSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+import { createInterface } from 'readline';
+
+const HOME = process.env.HOME || process.env.USERPROFILE || '';
+const args = process.argv.slice(2);
+const YES = args.includes('--yes') || args.includes('-y');
+const KEEP_AUTH = args.includes('--keep-auth');
+
+function log(msg: string): void { process.stdout.write(`${msg}\n`); }
+
+async function confirm(msg: string): Promise<boolean> {
+  if (YES) return true;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`  ${msg} [Y/n]: `, (answer) => {
+      rl.close();
+      resolve(!answer || answer.toLowerCase() === 'y');
+    });
+  });
+}
+
+function findLatestBackup(filePath: string): string | null {
+  const dir = dirname(filePath);
+  const base = filePath.split('/').pop() || '';
+  try {
+    const files = readdirSync(dir)
+      .filter(f => f.startsWith(`${base}.backup-`))
+      .sort()
+      .reverse();
+    return files.length > 0 ? join(dir, files[0]) : null;
+  } catch { return null; }
+}
+
+function removeGramatrFromJson(filePath: string, keys: string[]): boolean {
+  try {
+    if (!existsSync(filePath)) return false;
+    const data = JSON.parse(readFileSync(filePath, 'utf8'));
+    let changed = false;
+    for (const key of keys) {
+      if (key in data) {
+        delete data[key];
+        changed = true;
+      }
+      // Handle nested keys like "env.GMTR_TOKEN"
+      if (key.includes('.')) {
+        const [parent, child] = key.split('.');
+        if (data[parent] && child in data[parent]) {
+          delete data[parent][child];
+          changed = true;
+        }
+      }
+    }
+    // Remove gramatr from mcpServers
+    if (data.mcpServers?.gramatr) {
+      delete data.mcpServers.gramatr;
+      changed = true;
+    }
+    if (changed) {
+      writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
+    }
+    return changed;
+  } catch { return false; }
+}
+
+function dirSize(dir: string): string {
+  try {
+    let total = 0;
+    const walk = (d: string) => {
+      for (const f of readdirSync(d)) {
+        const p = join(d, f);
+        const s = statSync(p);
+        if (s.isDirectory()) walk(p); else total += s.size;
+      }
+    };
+    walk(dir);
+    if (total > 1048576) return `${(total / 1048576).toFixed(1)}MB`;
+    if (total > 1024) return `${(total / 1024).toFixed(0)}KB`;
+    return `${total}B`;
+  } catch { return '?'; }
+}
+
+async function main(): Promise<void> {
+  log('');
+  log('  gramatr uninstaller');
+  log('  ===================');
+  log('');
+
+  const gmtrClient = join(HOME, 'gmtr-client');
+  const gmtrJson = join(HOME, '.gmtr.json');
+  const gmtrDotDir = join(HOME, '.gmtr');
+  const claudeSettings = join(HOME, '.claude', 'settings.json');
+  const claudeJson = join(HOME, '.claude.json');
+  const claudeSkills = join(HOME, '.claude', 'skills');
+  const claudeAgents = join(HOME, '.claude', 'agents');
+  const claudeCommands = join(HOME, '.claude', 'commands');
+  const codexHooks = join(HOME, '.codex', 'hooks.json');
+  const codexAgents = join(HOME, '.codex', 'AGENTS.md');
+  const geminiExt = join(HOME, '.gemini', 'extensions', 'gramatr');
+
+  // Detect what's installed
+  const installed: string[] = [];
+  if (existsSync(gmtrClient)) installed.push(`~/gmtr-client (${dirSize(gmtrClient)})`);
+  if (existsSync(gmtrDotDir)) installed.push(`~/.gmtr/ (${dirSize(gmtrDotDir)})`);
+  if (existsSync(gmtrJson)) installed.push('~/.gmtr.json');
+  if (existsSync(claudeSettings)) installed.push('~/.claude/settings.json (hooks)');
+  if (existsSync(claudeJson)) installed.push('~/.claude.json (MCP server)');
+  if (existsSync(codexHooks)) installed.push('~/.codex/hooks.json');
+  if (existsSync(geminiExt)) installed.push(`~/.gemini/extensions/gramatr (${dirSize(geminiExt)})`);
+
+  if (installed.length === 0) {
+    log('  Nothing to uninstall — gramatr is not installed.');
+    log('');
+    return;
+  }
+
+  log('  Found:');
+  for (const item of installed) log(`    - ${item}`);
+  log('');
+
+  if (!await confirm('Proceed with uninstall?')) {
+    log('  Cancelled.');
+    return;
+  }
+
+  log('');
+
+  // 1. Remove ~/gmtr-client (hooks, bin, skills, agents, tools)
+  if (existsSync(gmtrClient)) {
+    rmSync(gmtrClient, { recursive: true, force: true });
+    log('  OK Removed ~/gmtr-client');
+  }
+
+  // 2. Remove ~/.gmtr/ (bun binary, PATH additions)
+  if (existsSync(gmtrDotDir)) {
+    rmSync(gmtrDotDir, { recursive: true, force: true });
+    log('  OK Removed ~/.gmtr/');
+  }
+
+  // 3. Remove ~/.gmtr.json (auth token) — unless --keep-auth
+  if (existsSync(gmtrJson)) {
+    if (KEEP_AUTH) {
+      log('  -- Kept ~/.gmtr.json (--keep-auth)');
+    } else {
+      rmSync(gmtrJson);
+      log('  OK Removed ~/.gmtr.json');
+    }
+  }
+
+  // 4. Restore ~/.claude/settings.json from backup or clean gramatr hooks
+  if (existsSync(claudeSettings)) {
+    const backup = findLatestBackup(claudeSettings);
+    if (backup && await confirm(`Restore settings.json from backup (${backup.split('/').pop()})?`)) {
+      const backupContent = readFileSync(backup, 'utf8');
+      writeFileSync(claudeSettings, backupContent);
+      log(`  OK Restored ~/.claude/settings.json from ${backup.split('/').pop()}`);
+    } else {
+      // Remove gramatr hooks from settings
+      try {
+        const settings = JSON.parse(readFileSync(claudeSettings, 'utf8'));
+        if (settings.hooks) {
+          // Remove hook entries that reference gmtr-client
+          for (const [event, hooks] of Object.entries(settings.hooks)) {
+            if (Array.isArray(hooks)) {
+              settings.hooks[event] = (hooks as any[]).filter(
+                (h: any) => !h.command?.includes('gmtr-client') && !h.command?.includes('gramatr')
+              );
+              if (settings.hooks[event].length === 0) delete settings.hooks[event];
+            }
+          }
+          if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+        }
+        if (settings.statusLine?.command?.includes('gmtr-client')) {
+          delete settings.statusLine;
+        }
+        writeFileSync(claudeSettings, JSON.stringify(settings, null, 2) + '\n');
+        log('  OK Removed gramatr hooks from ~/.claude/settings.json');
+      } catch {
+        log('  X Could not clean settings.json — restore from backup manually');
+      }
+    }
+  }
+
+  // 5. Remove gramatr from ~/.claude.json (MCP server + env vars)
+  if (existsSync(claudeJson)) {
+    const cleaned = removeGramatrFromJson(claudeJson, ['env.GMTR_TOKEN', 'env.AIOS_MCP_TOKEN']);
+    if (cleaned) log('  OK Removed gramatr MCP server + env vars from ~/.claude.json');
+  }
+
+  // 6. Remove gramatr skills from ~/.claude/skills/
+  if (existsSync(claudeSkills)) {
+    try {
+      const skillDirs = readdirSync(claudeSkills);
+      let removed = 0;
+      for (const dir of skillDirs) {
+        const skillPath = join(claudeSkills, dir);
+        // Check if it's a gramatr-installed skill (has gramatr marker or matches known patterns)
+        if (existsSync(join(skillPath, '.gramatr')) || existsSync(join(skillPath, 'README.md'))) {
+          rmSync(skillPath, { recursive: true, force: true });
+          removed++;
+        }
+      }
+      if (removed > 0) log(`  OK Removed ${removed} skill directories from ~/.claude/skills/`);
+    } catch { /* non-critical */ }
+  }
+
+  // 7. Remove gramatr agents from ~/.claude/agents/
+  if (existsSync(claudeAgents)) {
+    try {
+      rmSync(claudeAgents, { recursive: true, force: true });
+      log('  OK Removed ~/.claude/agents/');
+    } catch { /* non-critical */ }
+  }
+
+  // 8. Remove gramatr commands from ~/.claude/commands/
+  if (existsSync(claudeCommands)) {
+    try {
+      const cmds = readdirSync(claudeCommands).filter(f => f.startsWith('gmtr-') || f.startsWith('gramatr-'));
+      for (const cmd of cmds) {
+        rmSync(join(claudeCommands, cmd), { recursive: true, force: true });
+      }
+      if (cmds.length > 0) log(`  OK Removed ${cmds.length} gramatr commands from ~/.claude/commands/`);
+    } catch { /* non-critical */ }
+  }
+
+  // 9. Clean Codex config
+  if (existsSync(codexHooks)) {
+    try {
+      const hooks = JSON.parse(readFileSync(codexHooks, 'utf8'));
+      if (hooks.hooks) {
+        for (const [event, eventHooks] of Object.entries(hooks.hooks)) {
+          if (Array.isArray(eventHooks)) {
+            hooks.hooks[event] = (eventHooks as any[]).filter(
+              (h: any) => !h.command?.includes('gmtr-client') && !h.command?.includes('gramatr')
+            );
+            if (hooks.hooks[event].length === 0) delete hooks.hooks[event];
+          }
+        }
+        writeFileSync(codexHooks, JSON.stringify(hooks, null, 2) + '\n');
+        log('  OK Cleaned gramatr hooks from ~/.codex/hooks.json');
+      }
+    } catch { /* non-critical */ }
+  }
+  if (existsSync(codexAgents)) {
+    // Remove managed block from AGENTS.md
+    try {
+      let content = readFileSync(codexAgents, 'utf8');
+      const startMarker = '<!-- GMTR-CODEX-START -->';
+      const endMarker = '<!-- GMTR-CODEX-END -->';
+      const startIdx = content.indexOf(startMarker);
+      const endIdx = content.indexOf(endMarker);
+      if (startIdx !== -1 && endIdx !== -1) {
+        content = content.slice(0, startIdx) + content.slice(endIdx + endMarker.length);
+        writeFileSync(codexAgents, content.trim() + '\n');
+        log('  OK Removed gramatr block from ~/.codex/AGENTS.md');
+      }
+    } catch { /* non-critical */ }
+  }
+
+  // 10. Remove Gemini extension
+  if (existsSync(geminiExt)) {
+    rmSync(geminiExt, { recursive: true, force: true });
+    log('  OK Removed ~/.gemini/extensions/gramatr');
+  }
+
+  log('');
+  log('  Uninstall complete.');
+  log('  Restart Claude Code / Codex / Gemini CLI to apply changes.');
+  if (KEEP_AUTH) {
+    log('  Auth token preserved in ~/.gmtr.json (use --token with next install).');
+  }
+  log('');
+}
+
+main().catch((err) => {
+  log(`  Error: ${err.message}`);
+  process.exit(1);
+});