gramatr 0.3.0

package/bin/gramatr.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+/**
+ * gramatr CLI entry point — thin JS wrapper that bootstraps TypeScript.
+ * tsx is a production dependency, resolved directly from node_modules.
+ */
+const { spawnSync, execSync } = require('child_process');
+const { join, dirname } = require('path');
+
+const script = join(__dirname, 'gramatr.ts');
+const args = process.argv.slice(2);
+
+// Try bun first (fastest)
+let hasBun = false;
+try {
+  execSync('bun --version', { stdio: 'ignore' });
+  hasBun = true;
+} catch {}
+
+if (hasBun) {
+  const r = spawnSync('bun', [script, ...args], { stdio: 'inherit' });
+  process.exit(r.status ?? 1);
+}
+
+// Resolve tsx from node_modules (installed as dependency)
+try {
+  const tsxBin = join(dirname(require.resolve('tsx/package.json')), 'dist', 'cli.mjs');
+  const r = spawnSync(process.execPath, [tsxBin, script, ...args], { stdio: 'inherit' });
+  process.exit(r.status ?? 1);
+} catch {}
+
+// Last resort: npx tsx
+const r = spawnSync('npx', ['--yes', 'tsx', script, ...args], { stdio: 'inherit', shell: true });
+process.exit(r.status ?? 1);

package/bin/gramatr.ts

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { detectTargets, findTarget, summarizeDetectedLocalTargets, type IntegrationTargetId } from '../core/targets.ts';
+import { findStaleArtifacts, runLegacyMigration } from '../core/migration.ts';
+import { detectTsRunner } from '../core/install.ts';
+import {
+  formatDetectionLines,
+  formatDoctorLines,
+  formatInstallMenuLines,
+  formatRemoteGuidanceLines,
+  resolveInteractiveSelection,
+} 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 prompt(question: string): string {
+  process.stdout.write(question);
+  const input = spawnSync('bash', ['-lc', 'IFS= read -r line; printf "%s" "$line"'], {
+    stdio: ['inherit', 'pipe', 'inherit'],
+  });
+  return input.stdout?.toString('utf8').trim() || '';
+}
+
+function renderInstallMenu(): IntegrationTargetId[] {
+  const rendered = formatInstallMenuLines(detectTargets());
+  for (const line of rendered.lines) log(line);
+  return rendered.targetIds;
+}
+
+function runTs(script: string): void {
+  const runner = detectTsRunner();
+  if (runner === 'bun') {
+    run('bun', [script]);
+  } else {
+    // Resolve tsx from this package's node_modules (not CWD)
+    try {
+      const { dirname, join } = require('path');
+      const tsxCli = join(dirname(require.resolve('tsx/package.json')), 'dist', 'cli.mjs');
+      run(process.execPath, [tsxCli, script]);
+    } catch {
+      // Fallback: hope tsx is globally available
+      run('npx', ['tsx', script]);
+    }
+  }
+}
+
+function installTarget(targetId: IntegrationTargetId): void {
+  switch (targetId) {
+    case 'claude-code':
+      runTs(join(binDir, 'install.ts'));
+      return;
+    case 'codex':
+      runTs(join(clientDir, 'codex', 'install.ts'));
+      return;
+    case 'gemini-cli':
+      runTs(join(clientDir, 'gemini', 'install.ts'));
+      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): 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,
+  });
+}
+
+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 interactiveInstall(): void {
+  renderDetections();
+  log('');
+  const targetIds = renderInstallMenu();
+  const defaultChoice = summarizeDetectedLocalTargets()[0] || 'claude-code';
+  const answer = prompt(`Install target(s) [${defaultChoice}]: `) || defaultChoice;
+  const selections = resolveInteractiveSelection(
+    answer,
+    targetIds,
+    summarizeDetectedLocalTargets(),
+    (id) => findTarget(id) as { id: IntegrationTargetId; kind: 'local' | 'remote' } | undefined,
+  );
+  if (selections.length === 0) {
+    throw new Error('No install targets selected');
+  }
+
+  for (const selection of selections) {
+    installTarget(selection);
+  }
+
+  renderRemoteGuidance();
+}
+
+function main(): void {
+  const [, , command = 'install', targetArg] = process.argv;
+
+  switch (command) {
+    case 'install':
+      if (targetArg === '--detect') {
+        renderDetections();
+        return;
+      }
+      if (targetArg) {
+        if (targetArg === 'all') {
+          const targets = summarizeDetectedLocalTargets();
+          if (targets.length === 0) {
+            log('No detected local targets to install.');
+            return;
+          }
+          for (const target of targets) installTarget(target);
+          return;
+        }
+        const target = findTarget(targetArg);
+        if (!target) throw new Error(`Unknown target: ${targetArg}`);
+        installTarget(target.id);
+        return;
+      }
+      interactiveInstall();
+      return;
+    case 'detect':
+      renderDetections();
+      return;
+    case 'doctor':
+      doctor();
+      return;
+    case 'migrate':
+      migrate(targetArg === '--apply');
+      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('  detect             Show detected CLI platforms');
+      log('  doctor             Check installation health');
+      log('  upgrade            Upgrade all installed targets');
+      log('  migrate [--apply]  Clean up legacy artifacts');
+      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':
+      try {
+        const { VERSION } = require('../core/version.ts');
+        log(VERSION);
+      } catch {
+        log('0.3.0');
+      }
+      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();
+}