gramatr 0.3.0

package/gemini/hooks/user-prompt-submit.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+import {
+  deriveProjectId,
+  getGitContext,
+  readHookInput,
+} from '../../hooks/lib/gmtr-hook-utils.ts';
+import {
+  describeRoutingFailure,
+  persistClassificationResult,
+  routePrompt,
+  shouldSkipPromptRouting,
+} from '../../core/routing.ts';
+import {
+  buildHookFailureAdditionalContext,
+  buildGeminiHookOutput,
+  buildUserPromptAdditionalContext,
+  type RouteResponse,
+} from '../lib/gemini-hook-utils.ts';
+
+async function main(): Promise<void> {
+  try {
+    const input = await readHookInput();
+    const prompt = (input.prompt || input.message || '').trim();
+
+    if (shouldSkipPromptRouting(prompt)) {
+      return;
+    }
+
+    const git = getGitContext();
+    const projectId = git ? deriveProjectId(git.remote, git.projectName) : undefined;
+    const result = await routePrompt({
+      prompt,
+      projectId,
+      sessionId: input.session_id,
+      timeoutMs: 15000,
+    });
+    const route = result.route as RouteResponse | null;
+
+    if (!route) {
+      if (result.error) {
+        const failure = describeRoutingFailure(result.error);
+        const output = buildGeminiHookOutput(
+          buildHookFailureAdditionalContext(failure),
+          'gramatr request routing unavailable',
+        );
+        process.stdout.write(JSON.stringify(output));
+      }
+      return;
+    }
+
+    const additionalContext = buildUserPromptAdditionalContext(route);
+    if (git) {
+      persistClassificationResult({
+        rootDir: git.root,
+        prompt,
+        route,
+        downstreamModel: null,
+        clientType: 'gemini-cli',
+        agentName: 'Gemini CLI',
+      });
+    }
+    const output = buildGeminiHookOutput(
+      additionalContext,
+      'gramatr request routing active',
+    );
+
+    process.stdout.write(JSON.stringify(output));
+  } catch {
+    // Never block the user prompt if the hook fails.
+  }
+}
+
+void main();

package/gemini/install.ts

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import {
+  buildExtensionManifest,
+  buildGeminiHooksFile,
+  getGramatrExtensionDir,
+  readStoredApiKey,
+} from './lib/gemini-install-utils.ts';
+
+function log(message: string): void {
+  process.stdout.write(`${message}\n`);
+}
+
+function ensureDir(path: string): void {
+  if (!existsSync(path)) mkdirSync(path, { recursive: true });
+}
+
+function copyRecursive(source: string, target: string): void {
+  const stats = statSync(source);
+
+  if (stats.isDirectory()) {
+    ensureDir(target);
+    for (const entry of readdirSync(source)) {
+      copyRecursive(join(source, entry), join(target, entry));
+    }
+    return;
+  }
+
+  ensureDir(dirname(target));
+  copyFileSync(source, target);
+}
+
+async function promptForApiKey(): Promise<string | null> {
+  log('');
+  log('  gramatr requires authentication.');
+  log('  Options:');
+  log('    1. Run `bun gmtr-login.ts` first to authenticate via browser');
+  log('    2. Paste an API key below (starts with gmtr_sk_)');
+  log('');
+  process.stdout.write('  API Key (enter to skip): ');
+
+  const { createInterface } = await import('readline');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const key = await new Promise<string>((resolve) => {
+    rl.on('line', (line: string) => { rl.close(); resolve(line.trim()); });
+  });
+  return key || null;
+}
+
+async function testApiKey(key: string): Promise<boolean> {
+  try {
+    const res = await fetch('https://api.gramatr.com/mcp', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json, text/event-stream',
+        Authorization: `Bearer ${key}`,
+      },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: { name: 'aggregate_stats', arguments: {} },
+      }),
+      signal: AbortSignal.timeout(10000),
+    });
+
+    const text = await res.text();
+    if (
+      text.includes('JWT token is required') ||
+      text.includes('signature validation failed') ||
+      text.includes('Unauthorized')
+    ) {
+      return false;
+    }
+
+    for (const line of text.split('\n')) {
+      if (line.startsWith('data: ')) {
+        try {
+          const d = JSON.parse(line.slice(6));
+          if (d?.result?.content?.[0]?.text && !d?.result?.isError) {
+            return true;
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+async function resolveApiKey(home: string): Promise<string | null> {
+  // 1. Check if already stored in ~/.gmtr.json (shared with other platforms)
+  const stored = readStoredApiKey(home);
+  if (stored) {
+    log(`  Found existing token in ~/.gmtr.json`);
+    log('  Testing token...');
+    const valid = await testApiKey(stored);
+    if (valid) {
+      log('  OK Token is valid');
+      return stored;
+    }
+    log('  Token is invalid or expired. Please provide a new one.');
+  }
+
+  // 2. Check env var
+  const envKey = process.env.GRAMATR_API_KEY;
+  if (envKey) {
+    log('  Found GRAMATR_API_KEY in environment');
+    log('  Testing token...');
+    const valid = await testApiKey(envKey);
+    if (valid) {
+      log('  OK Token is valid');
+      return envKey;
+    }
+    log('  Environment token is invalid.');
+  }
+
+  // 3. Prompt
+  const prompted = await promptForApiKey();
+  if (prompted) {
+    log('  Testing token...');
+    const valid = await testApiKey(prompted);
+    if (valid) {
+      log('  OK Token is valid');
+      // Save to ~/.gmtr.json for cross-platform reuse
+      const configPath = join(home, '.gmtr.json');
+      let config: Record<string, unknown> = {};
+      if (existsSync(configPath)) {
+        try {
+          config = JSON.parse(readFileSync(configPath, 'utf8'));
+        } catch {
+          // start fresh
+        }
+      }
+      config.token = prompted;
+      config.token_type =
+        prompted.startsWith('gmtr_sk_') || prompted.startsWith('aios_sk_')
+          ? 'api_key'
+          : 'oauth';
+      config.authenticated_at = new Date().toISOString();
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+      log('  OK Saved to ~/.gmtr.json');
+      return prompted;
+    }
+    log('  Token rejected by server.');
+  }
+
+  return null;
+}
+
+async function main(): Promise<void> {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (!home) {
+    throw new Error('HOME is not set');
+  }
+
+  log('');
+  log('  gramatr Gemini CLI extension installer');
+  log('  ======================================');
+
+  // ── Resolve authentication ──
+  const apiKey = await resolveApiKey(home);
+  if (!apiKey) {
+    log('');
+    log('  WARNING: No valid API key configured.');
+    log('  The extension will be installed but MCP calls will fail without auth.');
+    log('  Run `bun gmtr-login.ts` to authenticate, then reinstall.');
+    log('');
+  }
+
+  // ── Determine paths ──
+  const currentFile = fileURLToPath(import.meta.url);
+  const geminiSourceDir = dirname(currentFile);
+  const clientSourceDir = dirname(geminiSourceDir);
+  const extensionDir = getGramatrExtensionDir(home);
+  const sharedHookUtilsSource = join(clientSourceDir, 'hooks', 'lib', 'gmtr-hook-utils.ts');
+  const sharedFeedbackSource = join(clientSourceDir, 'hooks', 'lib', 'classification-feedback.ts');
+  const sharedTranscriptSource = join(clientSourceDir, 'hooks', 'lib', 'transcript-parser.ts');
+  const sharedIdentitySource = join(clientSourceDir, 'hooks', 'lib', 'identity.ts');
+  const coreDir = join(clientSourceDir, 'core');
+
+  // ── Create extension directory ──
+  ensureDir(extensionDir);
+  ensureDir(join(extensionDir, 'hooks'));
+  ensureDir(join(extensionDir, 'hooks', 'lib'));
+  ensureDir(join(extensionDir, 'core'));
+
+  // ── Copy hook files ──
+  copyRecursive(join(geminiSourceDir, 'hooks'), join(extensionDir, 'hooks'));
+  copyRecursive(join(geminiSourceDir, 'lib'), join(extensionDir, 'lib'));
+  log('  OK Copied Gemini hook scripts');
+
+  // ── Copy shared dependencies ──
+  for (const sharedFile of [sharedHookUtilsSource, sharedFeedbackSource, sharedTranscriptSource, sharedIdentitySource]) {
+    if (existsSync(sharedFile)) {
+      const relativeDest = sharedFile.replace(clientSourceDir, '');
+      copyFileSync(sharedFile, join(extensionDir, relativeDest));
+    }
+  }
+
+  // Copy core shared modules
+  if (existsSync(coreDir)) {
+    for (const file of readdirSync(coreDir)) {
+      if (file.endsWith('.ts') && !file.endsWith('.test.ts')) {
+        copyFileSync(join(coreDir, file), join(extensionDir, 'core', file));
+      }
+    }
+  }
+  log('  OK Copied shared core and hook utilities');
+
+  // ── Write extension manifest ──
+  const manifest = buildExtensionManifest();
+  writeFileSync(
+    join(extensionDir, 'gemini-extension.json'),
+    JSON.stringify(manifest, null, 2) + '\n',
+  );
+  log('  OK Wrote gemini-extension.json manifest');
+
+  // ── Write hooks.json ──
+  const hooksFile = buildGeminiHooksFile();
+  writeFileSync(
+    join(extensionDir, 'hooks', 'hooks.json'),
+    JSON.stringify(hooksFile, null, 2) + '\n',
+  );
+  log('  OK Wrote hooks/hooks.json');
+
+  // ── Store token in ~/.gmtr.json (canonical source, not in extension dir) ──
+  if (apiKey) {
+    const gmtrJsonPath = join(home, '.gmtr.json');
+    let gmtrConfig: Record<string, unknown> = {};
+    if (existsSync(gmtrJsonPath)) {
+      try { gmtrConfig = JSON.parse(readFileSync(gmtrJsonPath, 'utf8')); } catch {}
+    }
+    gmtrConfig.token = apiKey;
+    gmtrConfig.token_updated_at = new Date().toISOString();
+    writeFileSync(gmtrJsonPath, JSON.stringify(gmtrConfig, null, 2) + '\n');
+    log('  OK Token stored in ~/.gmtr.json (hooks read from here at runtime)');
+  }
+
+  // ── Summary ──
+  log('');
+  log(`  Extension installed to: ${extensionDir}`);
+  log('');
+  log('  What was installed:');
+  log('    - gemini-extension.json  (MCP server + settings manifest)');
+  log('    - hooks/hooks.json       (SessionStart, BeforeAgent, SessionEnd)');
+  log('    - hooks/*.ts             (gramatr hook implementations)');
+  log('    - core/*.ts              (shared routing/session/formatting logic)');
+  if (apiKey) {
+    log('    - .env                   (authenticated API key)');
+  }
+  log('');
+  log('  Restart Gemini CLI to load the extension.');
+  log('');
+}
+
+main();

package/gemini/lib/gemini-hook-utils.ts

@@ -0,0 +1,63 @@
+import {
+  buildHookFailureAdditionalContext,
+  buildSessionStartAdditionalContext,
+  buildUserPromptAdditionalContext,
+} from '../../core/formatting.ts';
+import type {
+  HandoffResponse,
+  HookFailure,
+  RouteResponse,
+  SessionStartResponse,
+} from '../../core/types.ts';
+
+export type {
+  HandoffResponse,
+  HookFailure,
+  RouteResponse,
+  SessionStartResponse,
+};
+
+/**
+ * Gemini CLI hook output envelope.
+ *
+ * Gemini hooks return JSON on stdout with these fields:
+ *   continue    — whether to proceed with the agent loop
+ *   decision    — "allow" | "deny" | "block" (for gating hooks)
+ *   systemMessage — displayed in the terminal
+ *   hookSpecificOutput.additionalContext — injected into the LLM context
+ *
+ * See: https://github.com/google-gemini/gemini-cli/blob/main/docs/hooks/reference.md
+ */
+export interface GeminiHookOutput {
+  continue: boolean;
+  decision?: 'allow' | 'deny';
+  hookSpecificOutput?: {
+    additionalContext?: string;
+  };
+  systemMessage?: string;
+  suppressOutput?: boolean;
+}
+
+export {
+  buildHookFailureAdditionalContext,
+  buildSessionStartAdditionalContext,
+  buildUserPromptAdditionalContext,
+};
+
+export function buildGeminiHookOutput(
+  additionalContext: string,
+  systemMessage?: string,
+): GeminiHookOutput {
+  return {
+    continue: true,
+    ...(additionalContext
+      ? {
+          hookSpecificOutput: {
+            additionalContext,
+          },
+        }
+      : {}),
+    ...(systemMessage ? { systemMessage } : {}),
+    suppressOutput: true,
+  };
+}

package/gemini/lib/gemini-install-utils.ts

@@ -0,0 +1,169 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+export interface GeminiExtensionManifest {
+  name: string;
+  version: string;
+  description: string;
+  mcpServers?: Record<string, GeminiMcpServerConfig>;
+  settings?: GeminiSettingDef[];
+  contextFileName?: string;
+}
+
+export interface GeminiMcpServerConfig {
+  httpUrl?: string;
+  headers?: Record<string, string>;
+  timeout?: number;
+}
+
+export interface GeminiSettingDef {
+  name: string;
+  envVar: string;
+  sensitive?: boolean;
+  description?: string;
+}
+
+export interface GeminiHooksFileHook {
+  type: 'command';
+  command: string;
+  name?: string;
+  timeout?: number;
+  description?: string;
+}
+
+export interface GeminiHooksFileEntry {
+  matcher?: string;
+  sequential?: boolean;
+  hooks: GeminiHooksFileHook[];
+}
+
+export interface GeminiHooksFile {
+  hooks: Record<string, GeminiHooksFileEntry[]>;
+}
+
+/**
+ * Build the gemini-extension.json manifest for gramatr.
+ *
+ * The mcpServers block points to the production MCP endpoint.
+ * Auth is handled via the GRAMATR_API_KEY setting which Gemini stores
+ * in its extension .env / system keychain.
+ */
+export function buildExtensionManifest(): GeminiExtensionManifest {
+  return {
+    name: 'gramatr',
+    version: '1.0.0',
+    description: 'gramatr intelligence layer — decision routing, vector memory, and pattern learning for Gemini CLI',
+    mcpServers: {
+      gramatr: {
+        httpUrl: 'https://api.gramatr.com/mcp',
+        headers: {
+          Authorization: 'Bearer ${GRAMATR_API_KEY}',
+        },
+        timeout: 30000,
+      },
+    },
+    settings: [
+      {
+        name: 'API Key',
+        envVar: 'GRAMATR_API_KEY',
+        sensitive: true,
+        description: 'gramatr API key (starts with gmtr_sk_). Get one at gramatr.com or via gmtr-login.',
+      },
+    ],
+  };
+}
+
+/**
+ * Build the hooks/hooks.json for the gramatr Gemini extension.
+ *
+ * Maps Gemini CLI lifecycle events to gramatr hook scripts.
+ * Uses ${extensionPath} for portability — Gemini CLI expands this
+ * to the installed extension directory at runtime.
+ */
+export function buildGeminiHooksFile(): GeminiHooksFile {
+  return {
+    hooks: {
+      SessionStart: [
+        {
+          hooks: [
+            {
+              type: 'command',
+              command: 'bun "${extensionPath}/hooks/session-start.ts"',
+              name: 'gramatr-session-start',
+              timeout: 15,
+              description: 'Load gramatr session context and handoff',
+            },
+          ],
+        },
+      ],
+      BeforeAgent: [
+        {
+          hooks: [
+            {
+              type: 'command',
+              command: 'bun "${extensionPath}/hooks/user-prompt-submit.ts"',
+              name: 'gramatr-prompt-routing',
+              timeout: 15,
+              description: 'Route prompt through gramatr intelligence',
+            },
+          ],
+        },
+      ],
+      SessionEnd: [
+        {
+          hooks: [
+            {
+              type: 'command',
+              command: 'bun "${extensionPath}/hooks/stop.ts"',
+              name: 'gramatr-session-end',
+              timeout: 10,
+              description: 'Submit classification feedback to gramatr',
+            },
+          ],
+        },
+      ],
+    },
+  };
+}
+
+/**
+ * Read existing Gemini settings.json and extract the mcpServers block.
+ * Returns null if file doesn't exist or can't be parsed.
+ */
+export function readGeminiSettings(geminiHome: string): Record<string, unknown> | null {
+  const settingsPath = join(geminiHome, 'settings.json');
+  if (!existsSync(settingsPath)) return null;
+  try {
+    return JSON.parse(readFileSync(settingsPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve the Gemini extensions directory.
+ */
+export function getGeminiExtensionsDir(home: string): string {
+  return join(home, '.gemini', 'extensions');
+}
+
+/**
+ * Resolve the gramatr extension install path.
+ */
+export function getGramatrExtensionDir(home: string): string {
+  return join(getGeminiExtensionsDir(home), 'gramatr');
+}
+
+/**
+ * Read the stored API key from ~/.gmtr.json (shared with other platforms).
+ */
+export function readStoredApiKey(home: string): string | null {
+  const configPath = join(home, '.gmtr.json');
+  if (!existsSync(configPath)) return null;
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    return config.token || null;
+  } catch {
+    return null;
+  }
+}