ima-claude 2.9.0 → 2.13.0

package/platforms/gemini/adapter.ts

@@ -0,0 +1,443 @@
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { existsSync, readdirSync, statSync, readFileSync, writeFileSync, copyFileSync } from "fs";
+import { fileURLToPath } from "url";
+
+import type { PlatformAdapter, InstallItem, InstallPreview } from "../shared/types";
+import { ensureDir, copyDirRecursive, log, SKILLS_TO_INSTALL, HOOKS_TO_INSTALL, HOOKS_CONFIG, VERSION } from "../../scripts/utils";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const GEMINI_DIR = join(homedir(), ".gemini");
+const GEMINI_SKILLS_DIR = join(GEMINI_DIR, "skills");
+const GEMINI_AGENTS_DIR = join(GEMINI_DIR, "agents");
+const GEMINI_HOOKS_DIR = join(GEMINI_DIR, "hooks");
+const GEMINI_SETTINGS_FILE = join(GEMINI_DIR, "settings.json");
+const GEMINI_GUIDELINES_FILE = join(GEMINI_DIR, "GEMINI.md");
+
+// Claude Code → Gemini CLI tool name mapping
+const TOOL_MAP: Record<string, string> = {
+  Bash: "run_shell_command",
+  Read: "read_file",
+  Edit: "replace",
+  Write: "write_file",
+  Glob: "glob",
+  Grep: "grep_search",
+  LS: "list_directory",
+  WebSearch: "google_web_search",
+  WebFetch: "web_fetch",
+  ExitPlanMode: "exit_plan_mode",
+};
+
+// Claude Code → Gemini CLI hook event mapping
+const EVENT_MAP: Record<string, string> = {
+  PreToolUse: "BeforeTool",
+  PostToolUse: "AfterTool",
+  UserPromptSubmit: "BeforeAgent",
+  SessionStart: "SessionStart",
+};
+
+// Simple single-line YAML parser — same as Junie adapter.
+function parseFrontmatter(content: string): { frontmatter: Record<string, string>; body: string } {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return { frontmatter: {}, body: content };
+
+  const frontmatter: Record<string, string> = {};
+  for (const line of match[1].split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key) frontmatter[key] = value;
+  }
+
+  return { frontmatter, body: match[2] };
+}
+
+function serializeFrontmatter(frontmatter: Record<string, string>, body: string): string {
+  const lines = Object.entries(frontmatter).map(([k, v]) => `${k}: ${v}`);
+  return `---\n${lines.join("\n")}\n---\n${body}`;
+}
+
+function mapToolName(claudeName: string): string {
+  return TOOL_MAP[claudeName] ?? claudeName;
+}
+
+function transformAgentForGemini(content: string): string {
+  const { frontmatter, body } = parseFrontmatter(content);
+
+  // Drop permissionMode (Gemini uses global defaultApprovalMode)
+  // Drop model (let Gemini use its default)
+  const { permissionMode: _perm, model: _model, ...kept } = frontmatter;
+
+  // Map tool names in the tools field if present
+  if (kept.tools) {
+    const mapped = kept.tools
+      .split(",")
+      .map((t) => t.trim())
+      .map(mapToolName)
+      .join(", ");
+    kept.tools = mapped;
+  }
+
+  return serializeFrontmatter(kept, body);
+}
+
+function translateMatcher(matcher: string): string {
+  // MCP tool matchers pass through unchanged; only map built-in Claude tool names
+  return TOOL_MAP[matcher] ?? matcher;
+}
+
+function translateHookCommand(command: string): string {
+  // Rewrite hook commands to route through the translator shim
+  // Original: python3 ~/.claude/hooks/some_hook.py
+  // Gemini:   python3 ~/.gemini/hooks/hooks-translator.py ~/.gemini/hooks/some_hook.py
+  const hooksDir = GEMINI_HOOKS_DIR;
+  const translatorPath = join(hooksDir, "hooks-translator.py");
+
+  // Extract the script filename (and any trailing args) from the original command
+  const match = command.match(/python3\s+.*\/([^/\s]+\.py)(\s.*)?$/);
+  if (!match) return command;
+
+  const scriptName = match[1];
+  const trailingArgs = match[2] ?? "";
+  return `python3 ${translatorPath} ${join(hooksDir, scriptName)}${trailingArgs}`;
+}
+
+function generateGeminiHooksConfig(): Record<string, unknown> {
+  const geminiHooks: Record<string, unknown[]> = {};
+
+  for (const [claudeEvent, hookEntries] of Object.entries(HOOKS_CONFIG.hooks)) {
+    const geminiEvent = EVENT_MAP[claudeEvent] ?? claudeEvent;
+
+    geminiHooks[geminiEvent] = (hookEntries as Array<{ matcher?: string; hooks: Array<{ type: string; command: string }> }>).map(
+      (entry) => {
+        const translated: Record<string, unknown> = {};
+
+        if (entry.matcher) {
+          translated.matcher = translateMatcher(entry.matcher);
+        }
+
+        translated.hooks = entry.hooks.map((h) => ({
+          type: h.type,
+          command: translateHookCommand(h.command),
+        }));
+
+        return translated;
+      }
+    );
+  }
+
+  return { hooks: geminiHooks };
+}
+
+function generateGeminiMd(): string {
+  return `# ima-claude: AI Coding Agent Guidelines
+
+> Generated by ima-claude v${VERSION} for Gemini CLI.
+> Source: https://github.com/Soabirw/ima-claude
+
+## Default Persona: The Practitioner
+
+A 25-year software development veteran. FP-first, composition-minded, anti-over-engineering.
+Uses "we" not "I" — collaborative, humble, light-hearted. "Slow is smooth, smooth is fast."
+
+**Philosophy**: Simple > Complex | Evidence > Assumptions | Native > Utilities | MVP > Enterprise
+
+---
+
+## Memory Routing
+
+| Store what | Where | Why |
+|---|---|---|
+| Decisions, preferences, patterns, bugs | Vestige \`smart_ingest\` | Fades naturally if not referenced |
+| Reference material (docs, standards, PRDs) | Qdrant \`qdrant-store\` | Permanent library |
+| Session state, task progress | Serena \`write_memory\` | Project-scoped workbench |
+| Future reminders | Vestige \`intention\` | Surfaces at next session |
+
+At session start, check memory before asking questions:
+- Vestige: search for user preferences and project context
+- Vestige: check for pending reminders/intentions
+- Serena: list memories if in a Serena-activated project
+
+Auto-store: "I prefer..." → Vestige preference. "Let's go with X because..." → Vestige decision. "The reason this failed..." → Vestige bug.
+
+After completing work: store outcome in Vestige, reference material in Qdrant, session state in Serena.
+
+---
+
+## Orchestrator Protocol
+
+You are the Orchestrator. Plan and delegate. Do NOT implement directly.
+- Non-trivial work → task-planner (decompose) → task-runner (delegate)
+- Trivial = single file, < 5 lines, no judgment calls
+
+---
+
+## Available Agents
+
+Delegate to named agents — they enforce tools and permissions automatically.
+
+| Agent | Use For |
+|---|---|
+| \`explorer\` | File discovery, codebase exploration |
+| \`implementer\` | Feature dev, bug fixes, refactoring |
+| \`reviewer\` | Code review, security audit, FP checks |
+| \`wp-developer\` | WordPress plugins, themes, WP-CLI, forms |
+| \`memory\` | Memory search, storage, consolidation |
+
+---
+
+## Code Navigation (Serena)
+
+When Serena MCP is available, **prefer Serena over read_file/grep_search for code investigation.** 40-70% token savings.
+
+| Instead of | Use |
+|---|---|
+| Read file to understand structure | Serena get_symbols_overview |
+| grep_search for class/function definition | Serena find_symbol |
+| grep_search for callers/references | Serena find_referencing_symbols |
+
+Use read_file only when you need the actual implementation body of a known, specific symbol.
+
+---
+
+## Complex Reasoning
+
+Use sequential thinking before acting on:
+- Debugging / root cause analysis / "why is this failing"
+- Trade-off evaluation / "which approach"
+- Architectural decisions / design choices
+- Multi-step investigations where approach may change
+
+---
+
+## MCP Tool Routing
+
+| Signal | Preferred Tool |
+|---|---|
+| "latest", "2025/2026", "what's new" | Tavily search |
+| Library/framework API question | Context7 |
+| URL content extraction | Tavily extract (use advanced for complex pages) |
+
+Before web tools: check internal knowledge → Context7 → then Tavily.
+Before external lookups: check Vestige memory first.
+
+---
+
+## Search Preference
+
+Always prefer \`rg\` (ripgrep) over grep/find. Faster, respects .gitignore, recursive by default.
+
+---
+
+## Security
+
+- Verify nonce usage and input sanitization in WordPress PHP code
+- Never concatenate user input directly into SQL — use parameterized queries
+- Check for XSS, CSRF, and OWASP top 10 vulnerabilities in written code
+
+---
+
+## Code Style
+
+- Don't create custom FP utility functions (pipe, compose, curry) — use language-native patterns or established libraries
+- In WordPress JavaScript context, use jQuery patterns when jQuery is already loaded
+- Prefer Bootstrap utility classes over custom CSS overrides
+- Run \`composer dump-autoload\` after creating new PHP files
+
+---
+
+## Documentation
+
+Follow the three-tier documentation system:
+- **Active** — Living docs, kept current (README, API docs, architecture)
+- **Archive** — Historical reference, rarely updated (decisions, post-mortems)
+- **Transient** — Ephemeral, git-ignored (session notes, scratch)
+`;
+}
+
+export class GeminiAdapter implements PlatformAdapter {
+  readonly name = "gemini";
+  readonly displayName = "Gemini CLI";
+  readonly configDir = GEMINI_DIR;
+
+  detect(): boolean {
+    return existsSync(GEMINI_DIR);
+  }
+
+  preview(sourceDir: string): InstallPreview {
+    const skillItems: InstallItem[] = SKILLS_TO_INSTALL.map((skill) => ({
+      name: skill,
+      category: "skill" as const,
+      destPath: join(GEMINI_SKILLS_DIR, skill),
+      exists: existsSync(join(GEMINI_SKILLS_DIR, skill)),
+    })).filter((item) => existsSync(join(sourceDir, "skills", item.name)));
+
+    const agentsDir = join(sourceDir, "agents");
+    const agentItems: InstallItem[] = existsSync(agentsDir)
+      ? readdirSync(agentsDir)
+          .filter((f) => f.endsWith(".md"))
+          .map((file) => ({
+            name: file.replace(/\.md$/, ""),
+            category: "agent" as const,
+            destPath: join(GEMINI_AGENTS_DIR, file),
+            exists: existsSync(join(GEMINI_AGENTS_DIR, file)),
+          }))
+      : [];
+
+    const hookItems: InstallItem[] = HOOKS_TO_INSTALL.map((file) => ({
+      name: file,
+      category: "hook" as const,
+      destPath: join(GEMINI_HOOKS_DIR, file),
+      exists: existsSync(join(GEMINI_HOOKS_DIR, file)),
+    }));
+
+    // Include the translator shim and generated hooks.json
+    const translatorItem: InstallItem = {
+      name: "hooks-translator.py",
+      category: "hook",
+      destPath: join(GEMINI_HOOKS_DIR, "hooks-translator.py"),
+      exists: existsSync(join(GEMINI_HOOKS_DIR, "hooks-translator.py")),
+    };
+
+    const guidelineItem: InstallItem = {
+      name: "GEMINI.md",
+      category: "guideline",
+      destPath: GEMINI_GUIDELINES_FILE,
+      exists: existsSync(GEMINI_GUIDELINES_FILE),
+    };
+
+    return {
+      platform: this.name,
+      targetDir: GEMINI_DIR,
+      items: [...skillItems, ...agentItems, ...hookItems, translatorItem, guidelineItem],
+    };
+  }
+
+  installSkills(sourceDir: string, exclude?: string[]): void {
+    ensureDir(GEMINI_SKILLS_DIR);
+    const skills = exclude?.length
+      ? SKILLS_TO_INSTALL.filter((s) => !exclude.includes(s))
+      : SKILLS_TO_INSTALL;
+    for (const skill of skills) {
+      const src = join(sourceDir, skill);
+      if (existsSync(src) && statSync(src).isDirectory()) {
+        copyDirRecursive(src, join(GEMINI_SKILLS_DIR, skill));
+        log.step(`skill: ${skill}`);
+      }
+    }
+  }
+
+  installAgents(sourceDir: string, exclude?: string[]): void {
+    ensureDir(GEMINI_AGENTS_DIR);
+    const entries = readdirSync(sourceDir)
+      .filter((f) => f.endsWith(".md"))
+      .filter((f) => !exclude?.includes(f.replace(/\.md$/, "")));
+    for (const file of entries) {
+      const content = readFileSync(join(sourceDir, file), "utf8");
+      const transformed = transformAgentForGemini(content);
+      writeFileSync(join(GEMINI_AGENTS_DIR, file), transformed);
+      log.step(`agent: ${file}`);
+    }
+  }
+
+  installGuidelines(_pluginRoot: string): void {
+    ensureDir(GEMINI_DIR);
+    writeFileSync(GEMINI_GUIDELINES_FILE, generateGeminiMd());
+    log.step(`guidelines: ${GEMINI_GUIDELINES_FILE}`);
+  }
+
+  installHooks(sourceDir: string, exclude?: string[]): void {
+    ensureDir(GEMINI_HOOKS_DIR);
+
+    // Copy hook scripts
+    const hooks = exclude?.length
+      ? HOOKS_TO_INSTALL.filter((f) => !exclude.includes(f))
+      : HOOKS_TO_INSTALL;
+    for (const file of hooks) {
+      const src = join(sourceDir, file);
+      if (existsSync(src)) {
+        copyFileSync(src, join(GEMINI_HOOKS_DIR, file));
+        log.step(`hook: ${file}`);
+      }
+    }
+
+    // Copy the translator shim from the platform directory
+    const shimSrc = join(__dirname, "hooks-translator.py");
+    if (!existsSync(shimSrc)) {
+      throw new Error(`hooks-translator.py not found at ${shimSrc} — packaging error`);
+    }
+    copyFileSync(shimSrc, join(GEMINI_HOOKS_DIR, "hooks-translator.py"));
+    log.step("hook: hooks-translator.py (shim)");
+
+    // Generate Gemini-specific hooks.json
+    const hooksConfig = generateGeminiHooksConfig();
+    writeFileSync(join(GEMINI_HOOKS_DIR, "hooks.json"), JSON.stringify(hooksConfig, null, 2) + "\n");
+    log.step("hook: hooks.json (generated for Gemini)");
+
+    // Merge hooks into settings.json
+    mergeGeminiHooksIntoSettings(hooksConfig);
+  }
+
+  postInstall(): void {
+    log.info("Gemini CLI install complete. Verify:");
+    log.info(`  Skills:     ${GEMINI_SKILLS_DIR}`);
+    log.info(`  Agents:     ${GEMINI_AGENTS_DIR}`);
+    log.info(`  Hooks:      ${GEMINI_HOOKS_DIR}`);
+    log.info(`  Guidelines: ${GEMINI_GUIDELINES_FILE}`);
+    log.info("Also available as a Gemini extension — see gemini-extension.json in the repo.");
+  }
+}
+
+function mergeGeminiHooksIntoSettings(hooksConfig: Record<string, unknown>): void {
+  let settings: Record<string, unknown> = {};
+
+  if (existsSync(GEMINI_SETTINGS_FILE)) {
+    try {
+      const content = readFileSync(GEMINI_SETTINGS_FILE, "utf8");
+      settings = JSON.parse(content);
+    } catch {
+      settings = {};
+    }
+  }
+
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  const settingsHooks = settings.hooks as Record<string, unknown>;
+  const newHooks = hooksConfig.hooks as Record<string, Array<{ matcher?: string }>>;
+
+  // Merge each event type by matcher field (preserves user hooks)
+  for (const [event, entries] of Object.entries(newHooks)) {
+    if (!settingsHooks[event]) {
+      settingsHooks[event] = entries;
+      continue;
+    }
+
+    const existing = settingsHooks[event] as Array<{ matcher?: string }>;
+    for (const entry of entries) {
+      if (entry.matcher) {
+        const idx = existing.findIndex((h) => h.matcher === entry.matcher);
+        if (idx >= 0) {
+          existing[idx] = entry;
+        } else {
+          existing.push(entry);
+        }
+      } else {
+        // No matcher (e.g. BeforeAgent) — replace the matcherless entries
+        const matcherlessIdx = existing.findIndex((h) => !h.matcher);
+        if (matcherlessIdx >= 0) {
+          existing[matcherlessIdx] = entry;
+        } else {
+          existing.push(entry);
+        }
+      }
+    }
+  }
+
+  writeFileSync(GEMINI_SETTINGS_FILE, JSON.stringify(settings, null, 2) + "\n");
+  log.info("Merged hooks into ~/.gemini/settings.json");
+}
+

package/platforms/gemini/gemini-extension.json

@@ -0,0 +1,17 @@
+{
+  "name": "ima-claude",
+  "version": "2.13.0",
+  "description": "IMA's AI coding agent skills — FP patterns, architecture guidance, and team standards. 50+ skills, 24 hooks, 6 agents.",
+  "publisher": "Soabirw",
+  "repository": "https://github.com/Soabirw/ima-claude",
+  "contextFileName": "GEMINI.md",
+  "skills": {
+    "path": "${extensionPath}/skills"
+  },
+  "agents": {
+    "path": "${extensionPath}/agents"
+  },
+  "hooks": {
+    "path": "${extensionPath}/hooks/hooks.json"
+  }
+}

package/platforms/gemini/hooks-translator.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""Gemini CLI → Claude Code tool name translator shim.
+
+Sits between Gemini CLI and ima-claude hook scripts, translating
+Gemini tool names to their Claude Code equivalents so existing hooks
+work unmodified.
+
+Usage (in hooks.json):
+  python3 ~/.gemini/hooks/hooks-translator.py ~/.gemini/hooks/some_hook.py
+"""
+
+import json
+import subprocess
+import sys
+
+# Gemini CLI → Claude Code tool name mapping (reverse of adapter TOOL_MAP)
+GEMINI_TO_CLAUDE = {
+    "run_shell_command": "Bash",
+    "read_file": "Read",
+    "replace": "Edit",
+    "write_file": "Write",
+    "glob": "Glob",
+    "grep_search": "Grep",
+    "list_directory": "LS",
+    "google_web_search": "WebSearch",
+    "web_fetch": "WebFetch",
+    "exit_plan_mode": "ExitPlanMode",
+}
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: hooks-translator.py <hook-script> [args...]", file=sys.stderr)
+        sys.exit(1)
+
+    target_script = sys.argv[1]
+    extra_args = sys.argv[2:]
+
+    # Read JSON from stdin
+    try:
+        raw = sys.stdin.read()
+        data = json.loads(raw) if raw.strip() else {}
+    except json.JSONDecodeError as e:
+        print(f"hooks-translator: invalid JSON from stdin: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Translate tool_name if present
+    tool_name = data.get("tool_name", "")
+    if tool_name in GEMINI_TO_CLAUDE:
+        data["tool_name"] = GEMINI_TO_CLAUDE[tool_name]
+
+    # Pipe translated JSON to the actual hook script
+    translated = json.dumps(data)
+    result = subprocess.run(
+        ["python3", target_script] + extra_args,
+        input=translated,
+        stdout=None,
+        stderr=None,
+        text=True,
+    )
+
+    sys.exit(result.returncode)
+
+
+if __name__ == "__main__":
+    main()

package/platforms/shared/detector.ts

@@ -1,10 +1,12 @@
 import type { DetectedPlatform, PlatformAdapter } from "./types";
 import { ClaudeAdapter } from "../claude/adapter";
 import { JunieAdapter } from "../junie/adapter";
+import { GeminiAdapter } from "../gemini/adapter";
 
 const ADAPTERS: PlatformAdapter[] = [
   new ClaudeAdapter(),
   new JunieAdapter(),
+  new GeminiAdapter(),
 ];
 
 export function detectPlatforms(): DetectedPlatform[] {
@@ -12,7 +14,9 @@ export function detectPlatforms(): DetectedPlatform[] {
     const detected = adapter.detect();
     const note = adapter.name === "claude" && detected
       ? "Recommended: install via plugin marketplace instead"
-      : undefined;
+      : adapter.name === "gemini" && detected
+        ? "Also available as a Gemini extension"
+        : undefined;
 
     return { adapter, detected, note };
   });

package/plugins/ima-claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ima-claude",
-  "version": "2.9.0",
-  "description": "IMA's Claude Code skills for functional programming, architecture, and team standards. 47 skills, 24 hooks, default persona, 3-tier memory system.",
+  "version": "2.13.0",
+  "description": "IMA's Claude Code skills for functional programming, architecture, and team standards. 52 skills, 24 hooks, default persona, 3-tier memory system.",
   "author": {
     "name": "IMA",
     "url": "https://github.com/Soabirw/ima-claude"