@gramatr/client 0.5.1

package/bin/gramatr.ts

@@ -0,0 +1,374 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import { homedir } from 'os';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { detectTargets, findTarget, summarizeDetectedLocalTargets, type IntegrationTargetId } from '../core/targets.ts';
+import { VERSION } from '../core/version.ts';
+import { findStaleArtifacts, runDeepClean, runLegacyMigration } from '../core/migration.ts';
+import {
+  formatDetectionLines,
+  formatDoctorLines,
+  formatRemoteGuidanceLines,
+} from '../core/installer-cli.ts';
+
+const currentFile = fileURLToPath(import.meta.url);
+const binDir = dirname(currentFile);
+const clientDir = dirname(binDir);
+const repoRoot = dirname(dirname(clientDir));
+
+function log(message: string = ''): void {
+  process.stdout.write(`${message}\n`);
+}
+
+function run(command: string, args: string[], env: Record<string, string | undefined> = {}): void {
+  const result = spawnSync(command, args, {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: { ...process.env, ...env },
+  });
+
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+
+function renderDetections(): void {
+  for (const line of formatDetectionLines(detectTargets())) log(line);
+}
+
+function renderRemoteGuidance(): void {
+  for (const line of formatRemoteGuidanceLines(detectTargets())) log(line);
+}
+
+function runTs(script: string, extraArgs: string[] = []): void {
+  // Resolve tsx from this package's node_modules (not CWD) so `npx tsx` works
+  // even on hosts where the user hasn't globally installed tsx.
+  try {
+    // ESM-safe: createRequire gives us require.resolve for finding tsx on disk.
+    const req = createRequire(import.meta.url);
+    const tsxCli = join(dirname(req.resolve('tsx/package.json')), 'dist', 'cli.mjs');
+    run(process.execPath, [tsxCli, script, ...extraArgs]);
+  } catch {
+    // Fallback: global npx tsx
+    const npxBin = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    run(npxBin, ['tsx', script, ...extraArgs]);
+  }
+}
+
+// Forward flags like --yes, --name, --timezone to sub-installers
+const forwardedFlags = process.argv.slice(2).filter(a =>
+  a === '--yes' || a === '-y' || a === '--name' || a === '--timezone' ||
+  (process.argv[process.argv.indexOf(a) - 1] === '--name') ||
+  (process.argv[process.argv.indexOf(a) - 1] === '--timezone')
+);
+
+interface InstallAllResult {
+  id: IntegrationTargetId;
+  label: string;
+  status: 'ok' | 'fail' | 'skipped';
+  message?: string;
+}
+
+const INSTALL_ALL_CANDIDATES: Array<{ id: IntegrationTargetId; label: string }> = [
+  { id: 'claude-code', label: 'Claude Code' },
+  { id: 'codex', label: 'Codex' },
+  { id: 'gemini-cli', label: 'Gemini CLI' },
+  { id: 'claude-desktop', label: 'Claude Desktop' },
+  { id: 'chatgpt-desktop', label: 'ChatGPT Desktop' },
+];
+
+function installAll(): void {
+  const detections = detectTargets();
+  const detectedIds = new Set(
+    detections.filter((t) => t.kind === 'local' && t.detection.detected).map((t) => t.id),
+  );
+
+  log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  log(`  gramatr v${VERSION} — install all detected`);
+  log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  log('');
+
+  const results: InstallAllResult[] = [];
+
+  for (const candidate of INSTALL_ALL_CANDIDATES) {
+    if (!detectedIds.has(candidate.id)) {
+      results.push({ id: candidate.id, label: candidate.label, status: 'skipped', message: 'not detected' });
+      continue;
+    }
+    log(`━━━ Installing ${candidate.label} ━━━`);
+    try {
+      installTargetForAll(candidate.id);
+      results.push({ id: candidate.id, label: candidate.label, status: 'ok' });
+    } catch (err: any) {
+      results.push({
+        id: candidate.id,
+        label: candidate.label,
+        status: 'fail',
+        message: err?.message || String(err),
+      });
+      log(`  X ${candidate.label} install failed: ${err?.message || err}`);
+    }
+    log('');
+  }
+
+  // Summary
+  log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  log('  gramatr install summary');
+  log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  const pad = (s: string, n: number) => s + ' '.repeat(Math.max(1, n - s.length));
+  for (const r of results) {
+    const statusStr =
+      r.status === 'ok' ? 'OK'
+      : r.status === 'fail' ? 'FAIL'
+      : 'not detected — skipped';
+    log(`  ${pad(r.label, 18)}${statusStr}${r.message && r.status === 'fail' ? ` (${r.message})` : ''}`);
+  }
+  log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  log('');
+
+  const okList = results.filter((r) => r.status === 'ok');
+  if (okList.length > 0) {
+    log('  Next steps:');
+    let step = 1;
+    for (const r of okList) {
+      switch (r.id) {
+        case 'claude-code':
+          log(`    ${step++}. Restart Claude Code to pick up MCP server config`);
+          break;
+        case 'codex':
+          log(`    ${step++}. Restart Codex to load updated hooks`);
+          break;
+        case 'gemini-cli':
+          log(`    ${step++}. Restart Gemini CLI to load the extension`);
+          break;
+        case 'claude-desktop':
+          log(`    ${step++}. Restart Claude Desktop to load MCP server`);
+          break;
+        case 'chatgpt-desktop':
+          log(`    ${step++}. Restart ChatGPT Desktop to load MCP server`);
+          break;
+      }
+    }
+    log('');
+  }
+
+  const anyFail = results.some((r) => r.status === 'fail');
+  if (anyFail) process.exit(1);
+}
+
+function installTargetForAll(targetId: IntegrationTargetId): void {
+  switch (targetId) {
+    case 'claude-code':
+      runTs(join(binDir, 'install.ts'), forwardedFlags);
+      return;
+    case 'codex':
+      runTs(join(clientDir, 'codex', 'install.ts'), forwardedFlags);
+      return;
+    case 'gemini-cli':
+      runTs(join(clientDir, 'gemini', 'install.ts'), forwardedFlags);
+      return;
+    case 'claude-desktop':
+      runTs(join(clientDir, 'desktop', 'install.ts'), forwardedFlags);
+      return;
+    case 'chatgpt-desktop':
+      runTs(join(clientDir, 'chatgpt', 'install.ts'), forwardedFlags);
+      return;
+    default:
+      throw new Error(`Cannot install remote target '${targetId}' via install-all`);
+  }
+}
+
+function installTarget(targetId: IntegrationTargetId): void {
+  switch (targetId) {
+    case 'claude-code':
+      runTs(join(binDir, 'install.ts'), forwardedFlags);
+      return;
+    case 'codex':
+      runTs(join(clientDir, 'codex', 'install.ts'), forwardedFlags);
+      return;
+    case 'gemini-cli':
+      runTs(join(clientDir, 'gemini', 'install.ts'), forwardedFlags);
+      return;
+    case 'remote-mcp':
+    case 'claude-web':
+    case 'chatgpt-web':
+      log(`Remote target '${targetId}' is not a local hook install.`);
+      log('Use remote MCP / hosted-client setup for this target.');
+      log('Current remote targets are documentation/setup targets, not local filesystem installs.');
+      return;
+  }
+}
+
+function migrate(apply: boolean, deep: boolean = false): void {
+  const homeDir = homedir();
+  const clientDir = process.env.GMTR_DIR || join(homeDir, 'gmtr-client');
+  runLegacyMigration({
+    homeDir,
+    clientDir,
+    includeOptionalUx: process.env.GMTR_ENABLE_OPTIONAL_CLAUDE_UX === '1',
+    apply,
+    log,
+  });
+  if (deep) {
+    log('');
+    runDeepClean({ homeDir, apply, log });
+  }
+}
+
+function doctor(): void {
+  const gmtrDir = process.env.GMTR_DIR || join(homedir(), 'gmtr-client');
+  const stale = findStaleArtifacts(homedir(), gmtrDir, existsSync);
+  for (const line of formatDoctorLines(detectTargets(), gmtrDir, existsSync(gmtrDir), stale)) log(line);
+  renderRemoteGuidance();
+}
+
+function upgrade(): void {
+  const homeDir = homedir();
+  const clientDir = process.env.GMTR_DIR || join(homeDir, 'gmtr-client');
+  const stale = findStaleArtifacts(homeDir, clientDir, existsSync);
+  if (stale.length > 0) {
+    log('Cleaning stale legacy artifacts before upgrade...');
+    runLegacyMigration({
+      homeDir,
+      clientDir,
+      includeOptionalUx: process.env.GMTR_ENABLE_OPTIONAL_CLAUDE_UX === '1',
+      apply: true,
+      log,
+    });
+    log('');
+  }
+
+  const installed = summarizeDetectedLocalTargets();
+  if (installed.length === 0) {
+    log('No detected local targets to upgrade.');
+    renderRemoteGuidance();
+    return;
+  }
+
+  for (const target of installed) {
+    log(`Upgrading ${target}...`);
+    installTarget(target);
+  }
+
+  renderRemoteGuidance();
+}
+
+function main(): void {
+  // Skip forwarded-only flags (--yes, --name <v>, --timezone <v>) when picking
+  // the command and target. Keep command-specific flags like --apply, --detect,
+  // --help, --version so existing subcommands continue to work.
+  const raw = process.argv.slice(2);
+  const FORWARDED_ONLY = new Set(['--yes', '-y']);
+  const FORWARDED_WITH_VALUE = new Set(['--name', '--timezone']);
+  const positionals: string[] = [];
+  for (let i = 0; i < raw.length; i++) {
+    const a = raw[i];
+    if (FORWARDED_ONLY.has(a)) continue;
+    if (FORWARDED_WITH_VALUE.has(a)) { i++; continue; }
+    positionals.push(a);
+  }
+  const command = positionals[0] ?? 'install';
+  const targetArg = positionals[1];
+
+  switch (command) {
+    case 'install':
+      if (targetArg === '--detect') {
+        renderDetections();
+        return;
+      }
+      if (!targetArg || targetArg === 'all') {
+        installAll();
+        return;
+      }
+      if (targetArg === 'help' || targetArg === '--help' || targetArg === '-h') {
+        log('gramatr install — install gramatr into detected AI platforms');
+        log('');
+        log('Usage:');
+        log('  npx gramatr install              Detect every platform and install all');
+        log('  npx gramatr install all          Same as above (explicit)');
+        log('  npx gramatr install <platform>   Install a single platform');
+        log('');
+        log('Supported platforms:');
+        for (const c of INSTALL_ALL_CANDIDATES) {
+          log(`  ${c.id.padEnd(16)}${c.label}`);
+        }
+        return;
+      }
+      {
+        const target = findTarget(targetArg);
+        if (!target) {
+          log(`Unknown target: ${targetArg}. Run 'gramatr install help' for usage.`);
+          process.exit(1);
+        }
+        installTarget(target.id);
+      }
+      return;
+    case 'login':
+      runTs(join(binDir, 'gmtr-login.ts'), forwardedFlags);
+      return;
+    case 'add-api-key':
+      runTs(join(binDir, 'add-api-key.ts'), raw.slice(1));
+      return;
+    case 'logout':
+      runTs(join(binDir, 'logout.ts'), raw.slice(1));
+      return;
+    case 'clear-creds':
+      runTs(join(binDir, 'clear-creds.ts'), raw.slice(1));
+      return;
+    case 'detect':
+      renderDetections();
+      return;
+    case 'doctor':
+      doctor();
+      return;
+    case 'migrate': {
+      const flags = positionals.slice(1);
+      const apply = flags.includes('--apply');
+      const deep = flags.includes('--deep');
+      migrate(apply, deep);
+      return;
+    }
+    case 'upgrade':
+      upgrade();
+      return;
+    case '--help':
+    case '-h':
+    case 'help':
+      log('gramatr — your cross-agent AI brain');
+      log('');
+      log('Commands:');
+      log('  install [target]   Install gramatr (claude-code, codex, gemini-cli, all)');
+      log('  login              Authenticate with the gramatr server (OAuth)');
+      log('  add-api-key        Add an API key explicitly (interactive / piped / --from-env)');
+      log('  logout             Clear session token (~/.gmtr.json)');
+      log('  clear-creds        Nuke ALL stored credentials, force OAuth on next login');
+      log('  detect             Show detected CLI platforms');
+      log('  doctor             Check installation health');
+      log('  upgrade            Upgrade all installed targets');
+      log('  migrate [--apply] [--deep]  Clean up legacy artifacts (--deep also removes PAI/Fabric/aios)');
+      log('  help               Show this help');
+      log('');
+      log('Examples:');
+      log('  npx gramatr install              # Interactive target selection');
+      log('  npx gramatr install claude-code  # Install for Claude Code');
+      log('  npx gramatr install all          # Install all detected targets');
+      return;
+    case '--version':
+    case '-v':
+      log(VERSION);
+      return;
+    default:
+      log(`Unknown command: ${command}. Run 'gramatr help' for usage.`);
+      process.exit(1);
+  }
+}
+
+// import.meta.main is Bun-only; for Node/tsx, always run when executed directly
+const isMain = (import.meta as any).main ?? true;
+if (isMain) {
+  main();
+}