ima-claude 2.9.0

package/dist/cli.js

@@ -0,0 +1,1064 @@
+#!/usr/bin/env node
+
+// scripts/utils.ts
+import { existsSync, mkdirSync, readdirSync, statSync, copyFileSync, readFileSync, writeFileSync, unlinkSync, chmodSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { createInterface } from "readline";
+var CLAUDE_DIR = join(homedir(), ".claude");
+var SKILLS_DIR = join(CLAUDE_DIR, "skills");
+var HOOKS_DIR = join(CLAUDE_DIR, "hooks");
+var COMMANDS_DIR = join(CLAUDE_DIR, "commands");
+var RULES_DIR = join(CLAUDE_DIR, "rules");
+var SETTINGS_FILE = join(CLAUDE_DIR, "settings.json");
+var VERSION = "2.9.0";
+var colors = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m"
+};
+var log = {
+  info: (msg) => console.log(`${colors.cyan}\u2139${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.green}\u2705${colors.reset} ${msg}`),
+  warn: (msg) => console.log(`${colors.yellow}\u26A0\uFE0F${colors.reset} ${msg}`),
+  error: (msg) => console.error(`${colors.red}\u274C${colors.reset} ${msg}`),
+  step: (msg) => console.log(`${colors.blue}\u2192${colors.reset} ${msg}`)
+};
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function copyDirRecursive(src, dest) {
+  ensureDir(dest);
+  const entries = readdirSync(src);
+  for (const entry of entries) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    const stat = statSync(srcPath);
+    if (stat.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      if (existsSync(destPath)) {
+        try {
+          unlinkSync(destPath);
+        } catch {
+          chmodSync(destPath, 420);
+          unlinkSync(destPath);
+        }
+      }
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+async function promptYesNo(question, defaultYes = true) {
+  const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+  const answer = await prompt(`${question} ${suffix} `);
+  if (!answer) return defaultYes;
+  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
+var SKILLS_TO_INSTALL = [
+  // Foundational skills
+  "functional-programmer",
+  "task-master",
+  "task-planner",
+  "task-runner",
+  // FP implementation skills
+  "js-fp",
+  "js-fp-api",
+  "js-fp-react",
+  "js-fp-vue",
+  "js-fp-wordpress",
+  "php-fp",
+  "php-fp-wordpress",
+  "quasar-fp",
+  "jquery",
+  // Payment & API skills
+  "php-authnet",
+  // Domain expert skills
+  "architect",
+  "docs-organize",
+  "wp-local",
+  "rg",
+  "ima-forms-expert",
+  "ima-brand",
+  "ima-bootstrap",
+  "jira-checkpoint",
+  // Testing skills
+  "playwright",
+  // Discourse skills
+  "discourse",
+  "discourse-admin",
+  "ember-discourse",
+  // Integration skills
+  "compound-bridge",
+  // MCP integration skills
+  "mcp-atlassian",
+  "mcp-tavily",
+  "mcp-context7",
+  "mcp-serena",
+  "mcp-sequential",
+  "mcp-memory",
+  "mcp-vestige",
+  "mcp-qdrant",
+  // Quick reference
+  "quickstart",
+  "scorecard",
+  // Session management skills
+  "save-session",
+  "resume-session",
+  // Meta skills
+  "skill-analyzer",
+  "skill-creator"
+];
+var HOOKS_TO_INSTALL = [
+  // Tool redirection hooks
+  "enforce_rg_over_grep.py",
+  "tavily_extract_advanced.py",
+  "webfetch_to_tavily.py",
+  "websearch_to_tavily.py",
+  // Prompt coaching
+  "prompt_coach.py",
+  "prompt_coach_system.md",
+  "prompt_coach_digest.md",
+  // Memory system hooks
+  "memory_bootstrap.py",
+  "memory_store_reminder.py",
+  "vestige_before_external.py",
+  // Workflow hooks
+  "task_master_after_plan.py",
+  "task_master_before_impl.py",
+  "jira_issue_fetch.py",
+  // Security hooks
+  "wp_security_check.py",
+  "sql_injection_check.py",
+  // Atlassian prerequisite hooks
+  "atlassian_prereqs.py",
+  // Serena hooks
+  "serena_project_check.py",
+  "serena_over_grep.py",
+  "serena_over_read.py",
+  // Sequential Thinking hooks
+  "sequential_thinking_check.py",
+  // Code quality hooks
+  "fp_utility_check.py",
+  "jquery_in_wordpress.py",
+  "bootstrap_utility_check.py",
+  "composer_autoload_check.py",
+  "docs_organization.py"
+];
+var SERENA_JETBRAINS_TOOLS = [
+  "mcp__serena__jet_brains_find_symbol",
+  "mcp__serena__jet_brains_find_referencing_symbols",
+  "mcp__serena__jet_brains_get_symbols_overview",
+  "mcp__serena__jet_brains_type_hierarchy"
+];
+var ATLASSIAN_TOOLS_WITH_PREREQS = [
+  "mcp__claude_ai_Atlassian__getJiraIssue",
+  "mcp__claude_ai_Atlassian__editJiraIssue",
+  "mcp__claude_ai_Atlassian__createJiraIssue",
+  "mcp__claude_ai_Atlassian__searchJiraIssuesUsingJql",
+  "mcp__claude_ai_Atlassian__transitionJiraIssue",
+  "mcp__claude_ai_Atlassian__addCommentToJiraIssue",
+  "mcp__claude_ai_Atlassian__getConfluencePage",
+  "mcp__claude_ai_Atlassian__createConfluencePage",
+  "mcp__claude_ai_Atlassian__updateConfluencePage",
+  "mcp__claude_ai_Atlassian__searchConfluenceUsingCql",
+  "mcp__claude_ai_Atlassian__getAccessibleAtlassianResources",
+  "mcp__claude_ai_Atlassian__getTransitionsForJiraIssue"
+];
+var HOOKS_CONFIG = {
+  hooks: {
+    PreToolUse: [
+      {
+        matcher: "Bash",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/enforce_rg_over_grep.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/memory_bootstrap.py` }
+        ]
+      },
+      {
+        matcher: "Read",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/memory_bootstrap.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/serena_over_read.py` }
+        ]
+      },
+      {
+        matcher: "Edit",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/memory_bootstrap.py` }
+        ]
+      },
+      {
+        matcher: "Write",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/memory_bootstrap.py` }
+        ]
+      },
+      {
+        matcher: "Glob",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/memory_bootstrap.py` }
+        ]
+      },
+      {
+        matcher: "Grep",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/memory_bootstrap.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/serena_over_grep.py` }
+        ]
+      },
+      {
+        matcher: "mcp__tavily__tavily-extract",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/tavily_extract_advanced.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/vestige_before_external.py` }
+        ]
+      },
+      {
+        matcher: "mcp__tavily__tavily_search",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/vestige_before_external.py` }
+        ]
+      },
+      {
+        matcher: "mcp__tavily__tavily_research",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/vestige_before_external.py` }
+        ]
+      },
+      {
+        matcher: "mcp__context7__resolve-library-id",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/vestige_before_external.py` }
+        ]
+      },
+      {
+        matcher: "mcp__context7__query-docs",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/vestige_before_external.py` }
+        ]
+      },
+      {
+        matcher: "WebFetch",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/webfetch_to_tavily.py` }
+        ]
+      },
+      {
+        matcher: "WebSearch",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/websearch_to_tavily.py` }
+        ]
+      },
+      // Serena WP project path checks
+      ...SERENA_JETBRAINS_TOOLS.map((tool) => ({
+        matcher: tool,
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/serena_project_check.py` }
+        ]
+      })),
+      // Atlassian prerequisite checks
+      ...ATLASSIAN_TOOLS_WITH_PREREQS.map((tool) => ({
+        matcher: tool,
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/atlassian_prereqs.py` }
+        ]
+      }))
+    ],
+    PostToolUse: [
+      {
+        matcher: "Edit",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/memory_store_reminder.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/wp_security_check.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/sql_injection_check.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/fp_utility_check.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/jquery_in_wordpress.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/bootstrap_utility_check.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/composer_autoload_check.py` }
+        ]
+      },
+      {
+        matcher: "Write",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/memory_store_reminder.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/wp_security_check.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/sql_injection_check.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/fp_utility_check.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/jquery_in_wordpress.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/bootstrap_utility_check.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/composer_autoload_check.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/docs_organization.py` }
+        ]
+      },
+      {
+        matcher: "ExitPlanMode",
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/task_master_after_plan.py` }
+        ]
+      }
+    ],
+    UserPromptSubmit: [
+      {
+        hooks: [
+          { type: "command", command: `python3 ${HOOKS_DIR}/prompt_coach.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/jira_issue_fetch.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/task_master_before_impl.py` },
+          { type: "command", command: `python3 ${HOOKS_DIR}/sequential_thinking_check.py` }
+        ]
+      }
+    ]
+  }
+};
+function mergeHooksIntoSettings() {
+  let settings = {};
+  let created = false;
+  if (existsSync(SETTINGS_FILE)) {
+    try {
+      const content = readFileSync(SETTINGS_FILE, "utf8");
+      settings = JSON.parse(content);
+    } catch {
+      settings = {};
+    }
+  } else {
+    created = true;
+  }
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  const settingsHooks = settings.hooks;
+  if (settingsHooks.PreToolUse) {
+    const existingHooks = settingsHooks.PreToolUse;
+    const newHooks = HOOKS_CONFIG.hooks.PreToolUse;
+    for (const newHook of newHooks) {
+      const existingIndex = existingHooks.findIndex((h) => h.matcher === newHook.matcher);
+      if (existingIndex >= 0) {
+        existingHooks[existingIndex] = newHook;
+      } else {
+        existingHooks.push(newHook);
+      }
+    }
+  } else {
+    settingsHooks.PreToolUse = HOOKS_CONFIG.hooks.PreToolUse;
+  }
+  if (settingsHooks.PostToolUse) {
+    const existingHooks = settingsHooks.PostToolUse;
+    const newHooks = HOOKS_CONFIG.hooks.PostToolUse;
+    for (const newHook of newHooks) {
+      const existingIndex = existingHooks.findIndex((h) => h.matcher === newHook.matcher);
+      if (existingIndex >= 0) {
+        existingHooks[existingIndex] = newHook;
+      } else {
+        existingHooks.push(newHook);
+      }
+    }
+  } else {
+    settingsHooks.PostToolUse = HOOKS_CONFIG.hooks.PostToolUse;
+  }
+  settingsHooks.UserPromptSubmit = HOOKS_CONFIG.hooks.UserPromptSubmit;
+  writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2) + "\n");
+  return { merged: true, created };
+}
+
+// platforms/claude/adapter.ts
+import { join as join2 } from "path";
+import { existsSync as existsSync2, copyFileSync as copyFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+var AGENTS_DIR = join2(CLAUDE_DIR, "agents");
+var ClaudeAdapter = class {
+  name = "claude";
+  displayName = "Claude Code";
+  configDir = CLAUDE_DIR;
+  detect() {
+    return existsSync2(CLAUDE_DIR);
+  }
+  preview(sourceDir) {
+    const skillItems = SKILLS_TO_INSTALL.map((skill) => ({
+      name: skill,
+      category: "skill",
+      destPath: join2(SKILLS_DIR, skill),
+      exists: existsSync2(join2(SKILLS_DIR, skill))
+    }));
+    const agentsSourceDir = join2(sourceDir, "agents");
+    const agentItems = existsSync2(agentsSourceDir) ? readdirSync2(agentsSourceDir).filter((f) => f.endsWith(".md")).map((file) => ({
+      name: file.replace(/\.md$/, ""),
+      category: "agent",
+      destPath: join2(AGENTS_DIR, file),
+      exists: existsSync2(join2(AGENTS_DIR, file))
+    })) : [];
+    const hooksSourceDir = join2(sourceDir, "hooks");
+    const hookItems = HOOKS_TO_INSTALL.map((file) => ({
+      name: file,
+      category: "hook",
+      destPath: join2(HOOKS_DIR, file),
+      exists: existsSync2(join2(HOOKS_DIR, file))
+    }));
+    return {
+      platform: this.name,
+      targetDir: CLAUDE_DIR,
+      items: [...skillItems, ...agentItems, ...hookItems]
+    };
+  }
+  installSkills(sourceDir, exclude) {
+    ensureDir(SKILLS_DIR);
+    const skills = exclude?.length ? SKILLS_TO_INSTALL.filter((s) => !exclude.includes(s)) : SKILLS_TO_INSTALL;
+    for (const skill of skills) {
+      const src = join2(sourceDir, skill);
+      if (existsSync2(src) && statSync2(src).isDirectory()) {
+        copyDirRecursive(src, join2(SKILLS_DIR, skill));
+        log.step(`skill: ${skill}`);
+      }
+    }
+  }
+  installAgents(sourceDir, exclude) {
+    ensureDir(AGENTS_DIR);
+    const entries = readdirSync2(sourceDir).filter((f) => f.endsWith(".md"));
+    const filtered = exclude?.length ? entries.filter((f) => !exclude.includes(f.replace(/\.md$/, ""))) : entries;
+    for (const file of filtered) {
+      copyFileSync2(join2(sourceDir, file), join2(AGENTS_DIR, file));
+      log.step(`agent: ${file}`);
+    }
+  }
+  installGuidelines(_pluginRoot) {
+  }
+  installHooks(sourceDir, exclude) {
+    ensureDir(HOOKS_DIR);
+    const hooks = exclude?.length ? HOOKS_TO_INSTALL.filter((f) => !exclude.includes(f)) : HOOKS_TO_INSTALL;
+    for (const file of hooks) {
+      const src = join2(sourceDir, file);
+      if (existsSync2(src)) {
+        copyFileSync2(src, join2(HOOKS_DIR, file));
+        log.step(`hook: ${file}`);
+      }
+    }
+    const { created } = mergeHooksIntoSettings();
+    log.info(created ? "Created ~/.claude/settings.json with hooks" : "Merged hooks into ~/.claude/settings.json");
+  }
+  postInstall() {
+    log.warn("Note: Direct install is not the recommended approach for Claude Code.");
+    log.info("Prefer the plugin system instead:");
+    log.info("  /plugin marketplace add Soabirw/ima-claude");
+    log.info("  /plugin install ima-claude");
+  }
+};
+
+// platforms/junie/adapter.ts
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+var JUNIE_DIR = join3(homedir2(), ".junie");
+var JUNIE_SKILLS_DIR = join3(JUNIE_DIR, "skills");
+var JUNIE_AGENTS_DIR = join3(JUNIE_DIR, "agents");
+var JUNIE_GUIDELINES_FILE = join3(JUNIE_DIR, "AGENTS.md");
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return { frontmatter: {}, body: content };
+  const frontmatter = {};
+  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, body) {
+  const lines = Object.entries(frontmatter).map(([k, v]) => `${k}: ${v}`);
+  return `---
+${lines.join("\n")}
+---
+${body}`;
+}
+function transformAgentForJunie(content) {
+  const { frontmatter, body } = parseFrontmatter(content);
+  const { permissionMode: _dropped, ...junieFrontmatter } = frontmatter;
+  return serializeFrontmatter(junieFrontmatter, body);
+}
+function generateAgentsMd() {
+  return `# ima-claude: AI Coding Agent Guidelines
+
+> Generated by ima-claude v${VERSION} for Junie 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" \u2014 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..." \u2192 Vestige preference. "Let's go with X because..." \u2192 Vestige decision. "The reason this failed..." \u2192 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 \u2192 task-planner (decompose) \u2192 task-runner (delegate)
+- Trivial = single file, < 5 lines, no judgment calls
+- Model selection: opus for orchestration, sonnet for implementation (default), haiku for lookups
+
+---
+
+## Available Agents
+
+Delegate to named agents \u2014 they enforce model, tools, and permissions automatically.
+
+| Agent | Model | Use For |
+|---|---|---|
+| \`explorer\` | haiku | File discovery, codebase exploration |
+| \`implementer\` | sonnet | Feature dev, bug fixes, refactoring |
+| \`reviewer\` | sonnet | Code review, security audit, FP checks |
+| \`wp-developer\` | sonnet | WordPress plugins, themes, WP-CLI, forms |
+| \`memory\` | sonnet | Memory search, storage, consolidation |
+
+---
+
+## Code Navigation (Serena)
+
+When Serena MCP is available, **prefer Serena over Read/Grep for code investigation.** 40-70% token savings.
+
+| Instead of | Use |
+|---|---|
+| Read file to understand structure | Serena get_symbols_overview |
+| Grep for class/function definition | Serena find_symbol |
+| Grep for callers/references | Serena find_referencing_symbols |
+
+Use Read 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 \u2192 Context7 \u2192 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 \u2014 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) \u2014 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
+- Use proper Edit tools for code changes, not sed/awk
+
+---
+
+## Documentation
+
+Follow the three-tier documentation system:
+- **Active** \u2014 Living docs, kept current (README, API docs, architecture)
+- **Archive** \u2014 Historical reference, rarely updated (decisions, post-mortems)
+- **Transient** \u2014 Ephemeral, git-ignored (session notes, scratch)
+`;
+}
+var JunieAdapter = class {
+  name = "junie";
+  displayName = "Junie CLI";
+  configDir = JUNIE_DIR;
+  detect() {
+    return existsSync3(JUNIE_DIR);
+  }
+  preview(sourceDir) {
+    const skillItems = SKILLS_TO_INSTALL.map((skill) => ({
+      name: skill,
+      category: "skill",
+      destPath: join3(JUNIE_SKILLS_DIR, skill),
+      exists: existsSync3(join3(JUNIE_SKILLS_DIR, skill))
+    })).filter((item) => existsSync3(join3(sourceDir, "skills", item.name)));
+    const agentsDir = join3(sourceDir, "agents");
+    const agentItems = existsSync3(agentsDir) ? readdirSync3(agentsDir).filter((f) => f.endsWith(".md")).map((file) => ({
+      name: file.replace(/\.md$/, ""),
+      category: "agent",
+      destPath: join3(JUNIE_AGENTS_DIR, file),
+      exists: existsSync3(join3(JUNIE_AGENTS_DIR, file))
+    })) : [];
+    const guidelineItem = {
+      name: "AGENTS.md",
+      category: "guideline",
+      destPath: JUNIE_GUIDELINES_FILE,
+      exists: existsSync3(JUNIE_GUIDELINES_FILE)
+    };
+    return {
+      platform: this.name,
+      targetDir: JUNIE_DIR,
+      items: [...skillItems, ...agentItems, guidelineItem]
+    };
+  }
+  installSkills(sourceDir, exclude) {
+    ensureDir(JUNIE_SKILLS_DIR);
+    const skills = exclude?.length ? SKILLS_TO_INSTALL.filter((s) => !exclude.includes(s)) : SKILLS_TO_INSTALL;
+    for (const skill of skills) {
+      const src = join3(sourceDir, skill);
+      if (existsSync3(src) && statSync3(src).isDirectory()) {
+        copyDirRecursive(src, join3(JUNIE_SKILLS_DIR, skill));
+        log.step(`skill: ${skill}`);
+      }
+    }
+  }
+  installAgents(sourceDir, exclude) {
+    ensureDir(JUNIE_AGENTS_DIR);
+    const entries = readdirSync3(sourceDir).filter((f) => f.endsWith(".md")).filter((f) => !exclude?.includes(f.replace(/\.md$/, "")));
+    for (const file of entries) {
+      const content = readFileSync2(join3(sourceDir, file), "utf8");
+      const transformed = transformAgentForJunie(content);
+      writeFileSync2(join3(JUNIE_AGENTS_DIR, file), transformed);
+      log.step(`agent: ${file}`);
+    }
+  }
+  installGuidelines(_pluginRoot) {
+    ensureDir(JUNIE_DIR);
+    writeFileSync2(JUNIE_GUIDELINES_FILE, generateAgentsMd());
+    log.step(`guidelines: ${JUNIE_GUIDELINES_FILE}`);
+  }
+  postInstall() {
+    log.info("Junie install complete. Verify:");
+    log.info(`  Skills:     ${JUNIE_SKILLS_DIR}`);
+    log.info(`  Agents:     ${JUNIE_AGENTS_DIR}`);
+    log.info(`  Guidelines: ${JUNIE_GUIDELINES_FILE}`);
+    log.warn("Note: Junie does not support hooks \u2014 behavioral guidelines are in AGENTS.md instead.");
+  }
+};
+
+// platforms/shared/detector.ts
+var ADAPTERS = [
+  new ClaudeAdapter(),
+  new JunieAdapter()
+];
+function detectPlatforms() {
+  return ADAPTERS.map((adapter) => {
+    const detected = adapter.detect();
+    const note = adapter.name === "claude" && detected ? "Recommended: install via plugin marketplace instead" : void 0;
+    return { adapter, detected, note };
+  });
+}
+function getAdapter(name) {
+  return ADAPTERS.find((a) => a.name === name);
+}
+
+// platforms/shared/installer.ts
+import { join as join5 } from "path";
+
+// platforms/shared/types.ts
+import { join as join4, resolve, dirname as dirname2 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { fileURLToPath } from "url";
+function findPackageRoot() {
+  let dir;
+  try {
+    dir = dirname2(fileURLToPath(import.meta.url));
+  } catch {
+    dir = typeof __dirname !== "undefined" ? __dirname : resolve(".");
+  }
+  for (let i = 0; i < 10; i++) {
+    if (existsSync4(join4(dir, "package.json"))) return dir;
+    const parent = join4(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return process.cwd();
+}
+var PLUGIN_SOURCE = join4(
+  findPackageRoot(),
+  "plugins",
+  "ima-claude"
+);
+
+// platforms/shared/installer.ts
+function formatItemList(items, category) {
+  const filtered = items.filter((i) => i.category === category);
+  if (filtered.length === 0) return "";
+  const overrideCount = filtered.filter((i) => i.exists).length;
+  const overrideNote = overrideCount > 0 ? ` ${colors.yellow}(${overrideCount} existing will be overwritten)${colors.reset}` : "";
+  const names = filtered.map((i) => {
+    const marker = i.exists ? `${colors.yellow}*${colors.reset}` : " ";
+    return `${marker} ${i.name}`;
+  });
+  const label = category.charAt(0).toUpperCase() + category.slice(1) + "s";
+  return `  ${colors.bright}${label} (${filtered.length})${colors.reset}${overrideNote}
+${names.map((n) => `    ${n}`).join("\n")}`;
+}
+function showPreview(adapter, items) {
+  console.log(
+    `
+${colors.bright}Install preview for ${adapter.displayName}${colors.reset}`
+  );
+  console.log(`  Target: ${adapter.configDir}
+`);
+  const categories = ["skill", "agent", "hook", "guideline"];
+  for (const cat of categories) {
+    const section = formatItemList(items, cat);
+    if (section) console.log(section + "\n");
+  }
+  const existingCount = items.filter((i) => i.exists).length;
+  if (existingCount > 0) {
+    console.log(
+      `  ${colors.yellow}*${colors.reset} = exists and will be overwritten (${existingCount} files)
+`
+    );
+  }
+}
+async function promptExclusions(items) {
+  const filter = {};
+  console.log(`${colors.cyan}Options:${colors.reset}`);
+  console.log(`  [Enter]  Install all`);
+  console.log(`  [e]      Exclude specific items`);
+  console.log(`  [c]      Cancel
+`);
+  const choice = await prompt("Selection: ");
+  if (choice.toLowerCase() === "c") {
+    return { excludeSkills: items.filter((i) => i.category === "skill").map((i) => i.name) };
+  }
+  if (choice.toLowerCase() !== "e") {
+    return filter;
+  }
+  const skills = items.filter((i) => i.category === "skill");
+  const agents = items.filter((i) => i.category === "agent");
+  const hooks = items.filter((i) => i.category === "hook");
+  const guidelines = items.filter((i) => i.category === "guideline");
+  if (skills.length > 0) {
+    console.log(
+      `
+${colors.bright}Skills${colors.reset} (${skills.length} total)`
+    );
+    console.log(
+      `  Enter names to EXCLUDE (comma-separated), or press Enter to keep all:`
+    );
+    console.log(
+      `  ${colors.cyan}Available:${colors.reset} ${skills.map((s) => s.name).join(", ")}
+`
+    );
+    const excluded = await prompt("  Exclude: ");
+    if (excluded) {
+      filter.excludeSkills = excluded.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+  }
+  if (agents.length > 0) {
+    console.log(
+      `
+${colors.bright}Agents${colors.reset} (${agents.length} total)`
+    );
+    console.log(
+      `  Enter names to EXCLUDE (comma-separated), or press Enter to keep all:`
+    );
+    console.log(
+      `  ${colors.cyan}Available:${colors.reset} ${agents.map((a) => a.name).join(", ")}
+`
+    );
+    const excluded = await prompt("  Exclude: ");
+    if (excluded) {
+      filter.excludeAgents = excluded.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+  }
+  if (hooks.length > 0) {
+    console.log(
+      `
+${colors.bright}Hooks${colors.reset} (${hooks.length} total)`
+    );
+    console.log(
+      `  Enter names to EXCLUDE (comma-separated), or press Enter to keep all:`
+    );
+    console.log(
+      `  ${colors.cyan}Available:${colors.reset} ${hooks.map((h) => h.name).join(", ")}
+`
+    );
+    const excluded = await prompt("  Exclude: ");
+    if (excluded) {
+      filter.excludeHooks = excluded.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+  }
+  if (guidelines.length > 0) {
+    const skip = !await promptYesNo("\n  Install guidelines?", true);
+    filter.skipGuidelines = skip;
+  }
+  return filter;
+}
+async function installForPlatform(adapter, options = {}) {
+  const skillsSource = join5(PLUGIN_SOURCE, "skills");
+  const agentsSource = join5(PLUGIN_SOURCE, "agents");
+  const hooksSource = join5(PLUGIN_SOURCE, "hooks");
+  const preview = adapter.preview(PLUGIN_SOURCE);
+  showPreview(adapter, preview.items);
+  const filter = await promptExclusions(preview.items);
+  const allSkills = preview.items.filter((i) => i.category === "skill");
+  if (filter.excludeSkills && filter.excludeSkills.length >= allSkills.length) {
+    console.log("\nInstallation cancelled.\n");
+    return;
+  }
+  const excludedCount = (filter.excludeSkills?.length ?? 0) + (filter.excludeAgents?.length ?? 0) + (filter.excludeHooks?.length ?? 0) + (filter.skipGuidelines ? 1 : 0);
+  const totalItems = preview.items.length - excludedCount;
+  const proceed = await promptYesNo(
+    `
+Install ${totalItems} items to ${adapter.configDir}?`
+  );
+  if (!proceed) {
+    console.log("\nInstallation cancelled.\n");
+    return;
+  }
+  console.log(
+    `
+${colors.bright}Installing for ${adapter.displayName}${colors.reset}
+`
+  );
+  log.step(`Installing skills...`);
+  adapter.installSkills(skillsSource, filter.excludeSkills);
+  log.success(`Skills installed`);
+  log.step(`Installing agents...`);
+  adapter.installAgents(agentsSource, filter.excludeAgents);
+  log.success(`Agents installed`);
+  if (!filter.skipGuidelines) {
+    log.step(`Installing guidelines...`);
+    adapter.installGuidelines(PLUGIN_SOURCE);
+    log.success(`Guidelines installed`);
+  }
+  if (adapter.installHooks) {
+    log.step(`Installing hooks...`);
+    adapter.installHooks(hooksSource, filter.excludeHooks);
+    log.success(`Hooks installed`);
+  }
+  if (adapter.configureMcp && !options.skipMcp) {
+    log.step(`Configuring MCP servers...`);
+    await adapter.configureMcp();
+    log.success(`MCP configured`);
+  }
+  if (adapter.postInstall) {
+    adapter.postInstall();
+  }
+  console.log(
+    `
+${colors.green}Done!${colors.reset} ${adapter.displayName} installation complete.
+`
+  );
+}
+
+// scripts/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+function showHelp() {
+  console.log(`
+${colors.bright}ima-claude v${VERSION}${colors.reset}
+IMA's AI coding agent skills - FP patterns, architecture guidance, and team standards.
+
+${colors.cyan}Usage:${colors.reset}
+  ima-claude <command> [options]
+
+${colors.cyan}Commands:${colors.reset}
+  install             Interactive install (auto-detects platforms)
+  install --target X  Install for specific platform (claude, junie)
+  upgrade             Upgrade installed skills to latest version
+  detect              Show detected platforms
+  help                Show this help message
+
+${colors.cyan}Examples:${colors.reset}
+  npx ima-claude install
+  npx ima-claude install --target junie
+  npx ima-claude detect
+
+${colors.cyan}More Info:${colors.reset}
+  https://github.com/Soabirw/ima-claude
+`);
+}
+function showDetected() {
+  const platforms = detectPlatforms();
+  console.log(`
+${colors.bright}Detected AI Coding Agents${colors.reset}
+`);
+  for (const { adapter, detected, note } of platforms) {
+    const icon = detected ? `${colors.green}+${colors.reset}` : `${colors.red}-${colors.reset}`;
+    const status = detected ? "found" : "not detected";
+    console.log(`  ${icon} ${adapter.displayName} (${status})`);
+    if (note && detected) {
+      console.log(`    ${colors.yellow}${note}${colors.reset}`);
+    }
+  }
+  console.log("");
+}
+async function interactiveInstall() {
+  console.log(`
+${colors.bright}ima-claude v${VERSION} \u2014 Multi-Platform Installer${colors.reset}`);
+  console.log("Detecting installed AI coding agents...\n");
+  const platforms = detectPlatforms();
+  const detected = platforms.filter((p) => p.detected);
+  const notDetected = platforms.filter((p) => !p.detected);
+  for (const { adapter, note } of detected) {
+    console.log(`  ${colors.green}+${colors.reset} ${adapter.displayName}`);
+    if (adapter.name === "claude" && note) {
+      console.log(
+        `    ${colors.yellow}Tip:${colors.reset} For Claude Code, the plugin marketplace is recommended:`
+      );
+      console.log(
+        `    ${colors.cyan}/plugin marketplace add Soabirw/ima-claude${colors.reset}`
+      );
+      console.log(
+        `    ${colors.cyan}/plugin install ima-claude${colors.reset}`
+      );
+    }
+  }
+  for (const { adapter } of notDetected) {
+    console.log(`  ${colors.red}-${colors.reset} ${adapter.displayName} (not detected)`);
+  }
+  if (detected.length === 0) {
+    console.log(
+      `
+${colors.yellow}No supported platforms detected.${colors.reset}`
+    );
+    console.log("Install Claude Code or Junie CLI first, then run this installer again.\n");
+    return;
+  }
+  console.log("");
+  const toInstall = [];
+  for (const { adapter } of detected) {
+    if (adapter.name === "claude") {
+      const proceed = await promptYesNo(
+        `Install for ${adapter.displayName}? (Plugin marketplace is preferred)`,
+        false
+      );
+      if (proceed) toInstall.push(adapter);
+    } else {
+      const proceed = await promptYesNo(
+        `Install for ${adapter.displayName}?`,
+        true
+      );
+      if (proceed) toInstall.push(adapter);
+    }
+  }
+  if (toInstall.length === 0) {
+    console.log("\nNo platforms selected. Exiting.\n");
+    return;
+  }
+  for (const adapter of toInstall) {
+    await installForPlatform(adapter);
+  }
+}
+async function targetedInstall(targetName) {
+  const adapter = getAdapter(targetName);
+  if (!adapter) {
+    log.error(`Unknown target: ${targetName}`);
+    console.log("Available targets: claude, junie");
+    process.exit(1);
+  }
+  if (!adapter.detect()) {
+    log.warn(
+      `${adapter.displayName} not detected at ${adapter.configDir}`
+    );
+    const proceed = await promptYesNo("Install anyway?", false);
+    if (!proceed) {
+      console.log("Exiting.\n");
+      return;
+    }
+  }
+  if (adapter.name === "claude") {
+    console.log(
+      `
+${colors.yellow}Tip:${colors.reset} For Claude Code, the plugin marketplace is recommended:`
+    );
+    console.log(
+      `  ${colors.cyan}/plugin marketplace add Soabirw/ima-claude${colors.reset}`
+    );
+    console.log(
+      `  ${colors.cyan}/plugin install ima-claude${colors.reset}
+`
+    );
+    const proceed = await promptYesNo("Continue with direct install?", false);
+    if (!proceed) return;
+  }
+  await installForPlatform(adapter);
+}
+async function main() {
+  switch (command) {
+    case "install": {
+      const targetIdx = args.indexOf("--target");
+      if (targetIdx !== -1 && args[targetIdx + 1]) {
+        await targetedInstall(args[targetIdx + 1]);
+      } else {
+        await interactiveInstall();
+      }
+      break;
+    }
+    case "detect":
+      showDetected();
+      break;
+    case "upgrade":
+      console.log("Upgrade runs the same as install \u2014 detecting and updating.\n");
+      await interactiveInstall();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+    case void 0:
+      showHelp();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      showHelp();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});