ima-claude 2.10.0 → 2.14.0

package/platforms/gh-copilot/adapter.ts

@@ -0,0 +1,437 @@
+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 COPILOT_DIR = join(homedir(), ".copilot");
+const COPILOT_SKILLS_DIR = join(COPILOT_DIR, "skills");
+const COPILOT_AGENTS_DIR = join(COPILOT_DIR, "agents");
+const COPILOT_HOOKS_DIR = join(COPILOT_DIR, "hooks");
+const COPILOT_GUIDELINES_FILE = join(COPILOT_DIR, "copilot-instructions.md");
+
+// Claude Code → GitHub Copilot tool name mapping
+const TOOL_MAP: Record<string, string> = {
+  Bash: "run_terminal_command",
+  Read: "read_file",
+  Edit: "edit_file",
+  Write: "write_file",
+  Glob: "find_files",
+  Grep: "search_code",
+  LS: "list_directory",
+  WebSearch: "web_search",
+  WebFetch: "fetch_url",
+  ExitPlanMode: "ExitPlanMode",
+};
+
+// Claude Code → GitHub Copilot hook event mapping
+const EVENT_MAP: Record<string, string> = {
+  PreToolUse: "preToolUse",
+  PostToolUse: "postToolUse",
+  UserPromptSubmit: "userPromptSubmitted",
+  SessionStart: "sessionStart",
+};
+
+// Simple single-line YAML parser — same as Gemini/Junie adapters.
+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 transformAgentForCopilot(content: string): string {
+  const { frontmatter, body } = parseFrontmatter(content);
+
+  // Drop permissionMode (Copilot has no equivalent)
+  // Drop model (Copilot uses its own model selection)
+  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
+  // Copilot:  python3 ~/.copilot/hooks/hooks-translator.py ~/.copilot/hooks/some_hook.py
+  const hooksDir = COPILOT_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 generateCopilotHooksConfig(): Record<string, unknown> {
+  const copilotHooks: Record<string, unknown[]> = {};
+
+  for (const [claudeEvent, hookEntries] of Object.entries(HOOKS_CONFIG.hooks)) {
+    const copilotEvent = EVENT_MAP[claudeEvent] ?? claudeEvent;
+
+    // Flatten: Claude groups multiple hooks under one matcher,
+    // Copilot uses one flat entry per hook command
+    const flatEntries: Record<string, unknown>[] = [];
+
+    for (const entry of hookEntries as Array<{ matcher?: string; hooks: Array<{ type: string; command: string }> }>) {
+      const translatedMatcher = entry.matcher ? translateMatcher(entry.matcher) : undefined;
+
+      for (const hook of entry.hooks) {
+        const flatEntry: Record<string, unknown> = {};
+        if (translatedMatcher) {
+          flatEntry.matcher = translatedMatcher;
+        }
+        flatEntry.type = hook.type;
+        flatEntry.bash = translateHookCommand(hook.command);
+        flatEntries.push(flatEntry);
+      }
+    }
+
+    copilotHooks[copilotEvent] = flatEntries;
+  }
+
+  return { version: 1, hooks: copilotHooks };
+}
+
+function generateCopilotInstructionsMd(): string {
+  return `# ima-claude: AI Coding Agent Guidelines
+
+> Generated by ima-claude v${VERSION} for GitHub Copilot.
+> 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/search_code for code investigation.** 40-70% token savings.
+
+| Instead of | Use |
+|---|---|
+| Read file to understand structure | Serena get_symbols_overview |
+| search_code for class/function definition | Serena find_symbol |
+| search_code 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 GhCopilotAdapter implements PlatformAdapter {
+  readonly name = "gh-copilot";
+  readonly displayName = "GitHub Copilot";
+  readonly configDir = COPILOT_DIR;
+
+  detect(): boolean {
+    return existsSync(COPILOT_DIR);
+  }
+
+  preview(sourceDir: string): InstallPreview {
+    const skillItems: InstallItem[] = SKILLS_TO_INSTALL.map((skill) => ({
+      name: skill,
+      category: "skill" as const,
+      destPath: join(COPILOT_SKILLS_DIR, skill),
+      exists: existsSync(join(COPILOT_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(COPILOT_AGENTS_DIR, file.replace(/\.md$/, ".agent.md")),
+            exists: existsSync(join(COPILOT_AGENTS_DIR, file.replace(/\.md$/, ".agent.md"))),
+          }))
+      : [];
+
+    const hookItems: InstallItem[] = HOOKS_TO_INSTALL.map((file) => ({
+      name: file,
+      category: "hook" as const,
+      destPath: join(COPILOT_HOOKS_DIR, file),
+      exists: existsSync(join(COPILOT_HOOKS_DIR, file)),
+    }));
+
+    // Include the translator shim and generated hooks.json
+    const translatorItem: InstallItem = {
+      name: "hooks-translator.py",
+      category: "hook",
+      destPath: join(COPILOT_HOOKS_DIR, "hooks-translator.py"),
+      exists: existsSync(join(COPILOT_HOOKS_DIR, "hooks-translator.py")),
+    };
+
+    const guidelineItem: InstallItem = {
+      name: "copilot-instructions.md",
+      category: "guideline",
+      destPath: COPILOT_GUIDELINES_FILE,
+      exists: existsSync(COPILOT_GUIDELINES_FILE),
+    };
+
+    return {
+      platform: this.name,
+      targetDir: COPILOT_DIR,
+      items: [...skillItems, ...agentItems, ...hookItems, translatorItem, guidelineItem],
+    };
+  }
+
+  installSkills(sourceDir: string, exclude?: string[]): void {
+    ensureDir(COPILOT_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(COPILOT_SKILLS_DIR, skill));
+        log.step(`skill: ${skill}`);
+      }
+    }
+  }
+
+  installAgents(sourceDir: string, exclude?: string[]): void {
+    ensureDir(COPILOT_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 = transformAgentForCopilot(content);
+      // Copilot uses .agent.md extension
+      const destFile = file.replace(/\.md$/, ".agent.md");
+      writeFileSync(join(COPILOT_AGENTS_DIR, destFile), transformed);
+      log.step(`agent: ${destFile}`);
+    }
+  }
+
+  installGuidelines(_pluginRoot: string): void {
+    ensureDir(COPILOT_DIR);
+    writeFileSync(COPILOT_GUIDELINES_FILE, generateCopilotInstructionsMd());
+    log.step(`guidelines: ${COPILOT_GUIDELINES_FILE}`);
+  }
+
+  installHooks(sourceDir: string, exclude?: string[]): void {
+    ensureDir(COPILOT_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(COPILOT_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(COPILOT_HOOKS_DIR, "hooks-translator.py"));
+    log.step("hook: hooks-translator.py (shim)");
+
+    // Generate Copilot-specific hooks.json
+    const hooksConfig = generateCopilotHooksConfig();
+    const hooksConfigPath = join(COPILOT_HOOKS_DIR, "hooks.json");
+    mergeCopilotHooksConfig(hooksConfigPath, hooksConfig);
+    log.step("hook: hooks.json (generated for GitHub Copilot)");
+  }
+
+  postInstall(): void {
+    log.info("GitHub Copilot install complete. Verify:");
+    log.info(`  Skills:     ${COPILOT_SKILLS_DIR}`);
+    log.info(`  Agents:     ${COPILOT_AGENTS_DIR}`);
+    log.info(`  Hooks:      ${COPILOT_HOOKS_DIR}`);
+    log.info(`  Guidelines: ${COPILOT_GUIDELINES_FILE}`);
+  }
+}
+
+function mergeCopilotHooksConfig(
+  configPath: string,
+  newConfig: Record<string, unknown>
+): void {
+  let existing: Record<string, unknown> = {};
+
+  if (existsSync(configPath)) {
+    try {
+      const content = readFileSync(configPath, "utf8");
+      existing = JSON.parse(content);
+    } catch {
+      existing = {};
+    }
+  }
+
+  // Start with version from new config
+  existing.version = (newConfig as Record<string, unknown>).version ?? 1;
+
+  if (!existing.hooks) {
+    existing.hooks = {};
+  }
+  const existingHooks = existing.hooks as Record<string, unknown[]>;
+  const incomingHooks = (newConfig as Record<string, unknown>).hooks as Record<string, Array<{ matcher?: string }>>;
+
+  // Merge each event type: remove old ima-claude entries, then add new ones.
+  // User hooks (without hooks-translator.py in the command) are preserved.
+  for (const [event, entries] of Object.entries(incomingHooks)) {
+    if (!existingHooks[event]) {
+      existingHooks[event] = entries;
+      continue;
+    }
+
+    // Strip all old ima-claude entries (identified by hooks-translator.py in the bash command)
+    const userHooks = (existingHooks[event] as Array<{ bash?: string }>).filter(
+      (h) => !h.bash?.includes("hooks-translator.py")
+    );
+
+    // Append new ima-claude entries
+    existingHooks[event] = [...userHooks, ...entries];
+  }
+
+  writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
+}

package/platforms/gh-copilot/hook-translations.md

@@ -0,0 +1,91 @@
+# Hook-to-Copilot Translation Map
+
+This document tracks the relationship between Claude Code hooks and their
+GitHub Copilot equivalents. GitHub Copilot has full hook support (preToolUse,
+postToolUse, userPromptSubmitted, sessionStart), so all hooks translate 1:1
+via the hooks-translator.py shim — the same strategy as Gemini CLI.
+
+## Translation Strategy
+
+Copilot's hook system is functionally equivalent to Claude Code's. The
+`hooks-translator.py` shim sits between Copilot and each hook script,
+translating Copilot tool names to Claude Code equivalents so hook scripts
+work unmodified.
+
+Key differences from Claude Code:
+- Hook config uses `{ "version": 1, "hooks": { ... } }` format
+- Event names are camelCase: `preToolUse`, `postToolUse`, `userPromptSubmitted`
+- Each hook entry is flat: `{ matcher, type, bash }` (not grouped)
+- Uses `bash` field (not `command`)
+
+## Hook → Copilot Mapping
+
+### Tool Redirection Hooks → Translated (via shim)
+
+| Hook | Copilot Event | Matcher | Notes |
+|------|--------------|---------|-------|
+| `enforce_rg_over_grep.py` | preToolUse | run_terminal_command | Translates to Bash before hook runs |
+| `webfetch_to_tavily.py` | preToolUse | fetch_url | Translates to WebFetch before hook runs |
+| `websearch_to_tavily.py` | preToolUse | web_search | Translates to WebSearch before hook runs |
+| `tavily_extract_advanced.py` | preToolUse | mcp__tavily__tavily-extract | MCP matcher passthrough |
+
+### Memory Hooks → Translated (via shim)
+
+| Hook | Copilot Event | Notes |
+|------|--------------|-------|
+| `memory_bootstrap.py` | preToolUse | Runs on multiple tool matchers |
+| `memory_store_reminder.py` | postToolUse | Runs on Edit/Write |
+| `vestige_before_external.py` | preToolUse | Runs on Tavily/Context7 MCP tools |
+
+### Serena Hooks → Translated (via shim)
+
+| Hook | Copilot Event | Notes |
+|------|--------------|-------|
+| `serena_over_read.py` | preToolUse | read_file → Read translation |
+| `serena_over_grep.py` | preToolUse | search_code → Grep translation |
+| `serena_project_check.py` | preToolUse | MCP matcher passthrough |
+
+### Workflow Hooks → Translated (via shim)
+
+| Hook | Copilot Event | Notes |
+|------|--------------|-------|
+| `prompt_coach.py` | userPromptSubmitted | Calls Anthropic API — requires ANTHROPIC_API_KEY |
+| `task_master_before_impl.py` | userPromptSubmitted | Works unmodified |
+| `task_master_after_plan.py` | postToolUse | ExitPlanMode matcher passthrough |
+| `jira_issue_fetch.py` | userPromptSubmitted | Works unmodified |
+
+### Security Hooks → Translated (via shim)
+
+| Hook | Copilot Event | Notes |
+|------|--------------|-------|
+| `wp_security_check.py` | postToolUse | edit_file/write_file → Edit/Write translation |
+| `sql_injection_check.py` | postToolUse | edit_file/write_file → Edit/Write translation |
+
+### Code Quality Hooks → Translated (via shim)
+
+| Hook | Copilot Event | Notes |
+|------|--------------|-------|
+| `fp_utility_check.py` | postToolUse | edit_file/write_file → Edit/Write translation |
+| `jquery_in_wordpress.py` | postToolUse | edit_file/write_file → Edit/Write translation |
+| `bootstrap_utility_check.py` | postToolUse | edit_file/write_file → Edit/Write translation |
+| `composer_autoload_check.py` | postToolUse | edit_file/write_file → Edit/Write translation |
+| `docs_organization.py` | postToolUse | write_file → Write translation |
+| `block_sed_edits.py` | preToolUse | run_terminal_command → Bash translation |
+
+### Sequential Thinking → Translated (via shim)
+
+| Hook | Copilot Event | Notes |
+|------|--------------|-------|
+| `sequential_thinking_check.py` | userPromptSubmitted | Works unmodified |
+
+### Atlassian Hooks → Translated (via shim)
+
+| Hook | Copilot Event | Notes |
+|------|--------------|-------|
+| `atlassian_prereqs.py` | preToolUse | MCP matcher passthrough |
+
+### Session Hooks
+
+| Hook | Copilot Event | Notes |
+|------|--------------|-------|
+| `bootstrap.sh` | sessionStart | Content becomes copilot-instructions.md guidelines |

package/platforms/gh-copilot/hooks-translator.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""GitHub Copilot → Claude Code tool name translator shim.
+
+Sits between GitHub Copilot and ima-claude hook scripts, translating
+Copilot tool names to their Claude Code equivalents so existing hooks
+work unmodified.
+
+Usage (in hooks.json):
+  python3 ~/.copilot/hooks/hooks-translator.py ~/.copilot/hooks/some_hook.py
+"""
+
+import json
+import subprocess
+import sys
+
+# GitHub Copilot → Claude Code tool name mapping (reverse of adapter TOOL_MAP)
+COPILOT_TO_CLAUDE = {
+    "run_terminal_command": "Bash",
+    "read_file": "Read",
+    "edit_file": "Edit",
+    "write_file": "Write",
+    "find_files": "Glob",
+    "search_code": "Grep",
+    "list_directory": "LS",
+    "web_search": "WebSearch",
+    "fetch_url": "WebFetch",
+    "ExitPlanMode": "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 COPILOT_TO_CLAUDE:
+        data["tool_name"] = COPILOT_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,14 @@
 import type { DetectedPlatform, PlatformAdapter } from "./types";
 import { ClaudeAdapter } from "../claude/adapter";
 import { JunieAdapter } from "../junie/adapter";
+import { GeminiAdapter } from "../gemini/adapter";
+import { GhCopilotAdapter } from "../gh-copilot/adapter";
 
 const ADAPTERS: PlatformAdapter[] = [
   new ClaudeAdapter(),
   new JunieAdapter(),
+  new GeminiAdapter(),
+  new GhCopilotAdapter(),
 ];
 
 export function detectPlatforms(): DetectedPlatform[] {
@@ -12,7 +16,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.10.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.14.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"