raggrep 0.12.3 → 0.13.2

package/dist/cli/main.js

@@ -355,16 +355,30 @@ class ProgressManager {
     }
     this.logger.clearProgress();
   }
-  reportProgress(completed, total, message) {
+  reportProgress(completed, total, message, indexed, skipped) {
     this.state = {
       completed,
       total,
       message,
+      indexed,
+      skipped,
       timestamp: Date.now()
     };
   }
   writeProgress() {
-    const progressMessage = `  [${this.state.completed}/${this.state.total}] ${this.state.message}`;
+    let progressMessage = `  [${this.state.completed}/${this.state.total}] ${this.state.message}`;
+    if (this.state.indexed !== undefined || this.state.skipped !== undefined) {
+      const parts2 = [];
+      if (this.state.indexed !== undefined && this.state.indexed > 0) {
+        parts2.push(`${this.state.indexed} indexed`);
+      }
+      if (this.state.skipped !== undefined && this.state.skipped > 0) {
+        parts2.push(`${this.state.skipped} skipped`);
+      }
+      if (parts2.length > 0) {
+        progressMessage += ` (${parts2.join(", ")})`;
+      }
+    }
     this.logger.progress(progressMessage);
   }
 }
@@ -12095,6 +12109,8 @@ async function indexDirectory(rootDir, options = {}) {
     const moduleStart = Date.now();
     logger.info(`
 [${module2.name}] Starting indexing...`);
+    const moduleFiles = module2.supportsFile ? files.filter((f) => module2.supportsFile(f)) : files;
+    logger.info(`  Processing ${moduleFiles.length} files...`);
     const moduleConfig = getModuleConfig(config, module2.id);
     if (module2.initialize && moduleConfig) {
       const configWithOverrides = { ...moduleConfig };
@@ -12110,8 +12126,6 @@ async function indexDirectory(rootDir, options = {}) {
       };
       await module2.initialize(configWithOverrides);
     }
-    const moduleFiles = module2.supportsFile ? files.filter((f) => module2.supportsFile(f)) : files;
-    logger.info(`  Processing ${moduleFiles.length} files...`);
     const result = await indexWithModule(rootDir, moduleFiles, module2, config, verbose, introspection, logger, concurrency);
     results.push(result);
     if (module2.finalize) {
@@ -12346,11 +12360,12 @@ async function ensureIndexFresh(rootDir, options = {}) {
     const totalToProcess = filesToProcess.length;
     const progressManager = new ProgressManager(logger);
     progressManager.start();
+    let indexedCount = 0;
+    let mtimeUpdatedCount = 0;
     const processChangedFile = async (fileToProcess) => {
       const { filepath, relativePath, lastModified, isNew, existingContentHash } = fileToProcess;
       if (isLikelyBinary(filepath)) {
         completedCount++;
-        logger.debug(`  Skipping ${relativePath} (binary file)`);
         return { relativePath, status: "unchanged" };
       }
       try {
@@ -12358,6 +12373,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
         const contentHash = computeContentHash(content);
         if (!isNew && existingContentHash && existingContentHash === contentHash) {
           completedCount++;
+          mtimeUpdatedCount++;
           return {
             relativePath,
             status: "mtime_updated",
@@ -12366,7 +12382,8 @@ async function ensureIndexFresh(rootDir, options = {}) {
           };
         }
         completedCount++;
-        progressManager.reportProgress(completedCount, totalToProcess, `Indexing: ${relativePath}`);
+        indexedCount++;
+        progressManager.reportProgress(completedCount, totalToProcess, `Indexing: ${relativePath}`, indexedCount, mtimeUpdatedCount);
         introspection.addFile(relativePath, content);
         const fileIndex = await module2.indexFile(relativePath, content, ctx);
         if (!fileIndex) {
@@ -12427,6 +12444,19 @@ async function ensureIndexFresh(rootDir, options = {}) {
           break;
       }
     }
+    if (totalIndexed > 0 || mtimeUpdates > 0) {
+      const parts2 = [];
+      if (totalIndexed > 0) {
+        parts2.push(`${totalIndexed} indexed`);
+      }
+      if (mtimeUpdates > 0) {
+        parts2.push(`${mtimeUpdates} mtime-only`);
+      }
+      if (totalRemoved > 0) {
+        parts2.push(`${totalRemoved} removed`);
+      }
+      logger.info(`  [${module2.name}] ${parts2.join(", ")}`);
+    }
     const hasManifestChanges = totalIndexed > 0 || totalRemoved > 0 || mtimeUpdates > 0;
     if (hasManifestChanges) {
       manifest.lastUpdated = new Date().toISOString();
@@ -12527,19 +12557,18 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
   const progressManager = new ProgressManager(logger);
   progressManager.start();
   let completedCount = 0;
+  let indexedCount = 0;
+  let skippedCount = 0;
   const processFile = async (filepath, _index) => {
     const relativePath = path22.relative(rootDir, filepath);
-    if (isLikelyBinary(filepath)) {
-      completedCount++;
-      logger.debug(`  [${completedCount}/${totalFiles}] Skipped ${relativePath} (binary file)`);
-      return { relativePath, status: "skipped" };
-    }
     try {
       const stats = await fs8.stat(filepath);
       const lastModified = stats.mtime.toISOString();
       const existingEntry = manifest.files[relativePath];
       if (existingEntry && existingEntry.lastModified === lastModified) {
         completedCount++;
+        skippedCount++;
+        progressManager.reportProgress(completedCount, totalFiles, `Processing: ${relativePath}`, indexedCount, skippedCount);
         logger.debug(`  [${completedCount}/${totalFiles}] Skipped ${relativePath} (unchanged)`);
         return { relativePath, status: "skipped" };
       }
@@ -12547,6 +12576,8 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
       const contentHash = computeContentHash(content);
       if (existingEntry?.contentHash && existingEntry.contentHash === contentHash) {
         completedCount++;
+        skippedCount++;
+        progressManager.reportProgress(completedCount, totalFiles, `Processing: ${relativePath}`, indexedCount, skippedCount);
         logger.debug(`  [${completedCount}/${totalFiles}] Skipped ${relativePath} (content unchanged)`);
         return {
           relativePath,
@@ -12557,9 +12588,12 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
       }
       introspection.addFile(relativePath, content);
       completedCount++;
-      progressManager.reportProgress(completedCount, totalFiles, `Processing: ${relativePath}`);
+      indexedCount++;
+      progressManager.reportProgress(completedCount, totalFiles, `Processing: ${relativePath}`, indexedCount, skippedCount);
       const fileIndex = await module2.indexFile(relativePath, content, ctx);
       if (!fileIndex) {
+        skippedCount++;
+        progressManager.reportProgress(completedCount, totalFiles, `Processing: ${relativePath}`, indexedCount, skippedCount);
         logger.debug(`  [${completedCount}/${totalFiles}] Skipped ${relativePath} (no chunks)`);
         return { relativePath, status: "skipped" };
       }
@@ -14488,13 +14522,533 @@ var init_search = __esm(() => {
   init_indexer();
 });
 
+// src/app/cli/opencode/version-check.ts
+function parseOpenCodeVersion(version) {
+  const match2 = version.match(/v?(\d+)\.(\d+)\.(\d+)/);
+  if (!match2) {
+    return null;
+  }
+  return {
+    major: parseInt(match2[1], 10),
+    minor: parseInt(match2[2], 10),
+    patch: parseInt(match2[3], 10)
+  };
+}
+function supportsSkills(version) {
+  const parsed = parseOpenCodeVersion(version);
+  if (!parsed) {
+    return true;
+  }
+  if (parsed.major > 1)
+    return true;
+  if (parsed.major === 1 && parsed.minor > 0)
+    return true;
+  if (parsed.major === 1 && parsed.minor === 0 && parsed.patch >= 186)
+    return true;
+  return false;
+}
+function getInstallationMethod(openCodeVersion) {
+  if (!openCodeVersion) {
+    return "skill";
+  }
+  return supportsSkills(openCodeVersion) ? "skill" : "tool";
+}
+async function detectOpenCodeVersion() {
+  try {
+    const os4 = await import("os");
+    const fs10 = await import("fs/promises");
+    const path25 = await import("path");
+    const homeDir = os4.homedir();
+    const possiblePaths = [
+      path25.join(homeDir, ".local", "share", "opencode", "package.json"),
+      path25.join(homeDir, ".config", "opencode", "package.json"),
+      path25.join(homeDir, ".npm", "global", "node_modules", "opencode", "package.json")
+    ];
+    for (const packagePath of possiblePaths) {
+      try {
+        const content = await fs10.readFile(packagePath, "utf-8");
+        const pkg = JSON.parse(content);
+        if (pkg.version) {
+          return pkg.version;
+        }
+      } catch {}
+    }
+    try {
+      const { spawn } = await import("child_process");
+      return new Promise((resolve6) => {
+        const proc = spawn("opencode", ["--version"], { stdio: "pipe" });
+        let version = "";
+        proc.stdout.on("data", (data) => {
+          version += data.toString();
+        });
+        proc.on("close", (code) => {
+          if (code === 0) {
+            const match2 = version.match(/v?(\d+\.\d+\.\d+)/);
+            resolve6(match2 ? match2[1] : null);
+          } else {
+            resolve6(null);
+          }
+        });
+        setTimeout(() => {
+          proc.kill();
+          resolve6(null);
+        }, 3000);
+      });
+    } catch {}
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/app/cli/opencode/install-tool.ts
+async function installTool(options = {}) {
+  const { logger, checkForOldSkill = true } = options;
+  const os4 = await import("os");
+  const fs10 = await import("fs/promises");
+  const path25 = await import("path");
+  const homeDir = os4.homedir();
+  const toolDir = path25.join(homeDir, ".config", "opencode", "tool");
+  const toolPath = path25.join(toolDir, "raggrep.ts");
+  let removedOldSkill = false;
+  const toolContent = `import { tool } from "@opencode-ai/plugin";
+
+/**
+ * Check if raggrep is installed globally
+ */
+async function isRagrepInstalled(): Promise<boolean> {
+  try {
+    const proc = Bun.spawn(['raggrep', '--version'], { stdout: 'pipe', stderr: 'pipe' });
+    await proc.exited;
+    return proc.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the installed raggrep version
+ */
+async function getRagrepVersion(): Promise<string | null> {
+  try {
+    const proc = Bun.spawn(['raggrep', '--version'], { stdout: 'pipe', stderr: 'pipe' });
+    const output = await new Response(proc.stdout).text();
+    const match = output.match(/v([\\\\d.]+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+export default tool({
+  description:
+    "Semantic code search powered by RAG - understands INTENT, not just literal text. Parses code using AST to extract functions, classes, and symbols with full context. Finds relevant code even when exact keywords don't match. Superior to grep for exploratory searches like 'authentication logic', 'error handling patterns', or 'configuration loading'.\\\\n\\\\n\uD83C\uDFAF USE THIS TOOL FIRST when you need to:\\\\n• Find WHERE code is located (functions, components, services)\\\\n• Understand HOW code is structured\\\\n• Discover RELATED code across multiple files\\\\n• Get a QUICK overview of a topic\\\\n\\\\n❌ DON'T read multiple files manually when you can:\\\\n  raggrep(\\"user authentication\\", { filter: [\\"src/\\"] })\\\\n\\\\n✅ INSTEAD of reading files one-by-one, search semantically:\\\\n  • \\"Find the auth middleware\\" vs read: auth.ts, middleware.ts, index.ts...\\\\n  • \\"Where are React components?\\" vs read: App.tsx, components/*, pages/*...\\\\n  • \\"Database connection logic?\\" vs read: db.ts, config.ts, models/*...\\\\n  • \\"Error handling patterns\\" vs read: error.ts, middleware.ts, handlers/*...\\\\n\\\\nThis saves ~10x tool calls and provides BETTER context by showing related code across the entire codebase.",
+  args: {
+    query: tool.schema
+      .string()
+      .describe(
+        "Natural language search query describing what you want to find. Be specific: 'auth middleware that checks JWT', 'React hooks for data fetching', 'database connection pool config'. This is MUCH faster than reading files manually."
+      ),
+    filter: tool.schema
+      .array(tool.schema.string())
+      .describe(
+        "Array of path prefixes or glob patterns to narrow search scope (OR logic). If user mentions a directory, use it. Otherwise infer from context. Common patterns: ['src/auth'], ['*.tsx', 'components/'], ['api/', 'routes/'], ['docs/', '*.md'], ['*.test.ts']. For broad search use ['src/'] or ['**/*']."
+      ),
+    top: tool.schema
+      .number()
+      .optional()
+      .describe("Number of results to return (default: 10)"),
+    minScore: tool.schema
+      .number()
+      .optional()
+      .describe("Minimum similarity score 0-1 (default: 0.15)"),
+    type: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Filter by single file extension without dot (e.g., 'ts', 'tsx', 'js', 'md'). Prefer using 'filter' with glob patterns like '*.ts' for more flexibility."
+      ),
+  },
+  async execute(args) {
+    const installed = await isRagrepInstalled();
+
+    if (!installed) {
+      return \`Error: raggrep is not installed globally.
+
+Please install raggrep using one of the following commands:
+  npm install -g raggrep@latest
+  pnpm install -g raggrep@latest
+
+After installation, raggrep will be available for use.\`;
+    }
+
+    const cmdArgs = [args.query];
+
+    if (args.top !== undefined) {
+      cmdArgs.push("--top", String(args.top));
+    }
+    if (args.minScore !== undefined) {
+      cmdArgs.push("--min-score", String(args.minScore));
+    }
+    if (args.type !== undefined) {
+      cmdArgs.push("--type", args.type);
+    }
+    if (args.filter !== undefined && args.filter.length > 0) {
+      for (const f of args.filter) {
+        cmdArgs.push("--filter", f);
+      }
+    }
+
+    const proc = Bun.spawn(['raggrep', 'query', ...cmdArgs], { stdout: 'pipe' });
+    const result = await new Response(proc.stdout).text();
+    return result.trim();
+  },
+});
+`;
+  try {
+    if (checkForOldSkill) {
+      const oldSkillDir = path25.join(homeDir, ".config", "opencode", "skill", "raggrep");
+      const oldSkillPath = path25.join(oldSkillDir, "SKILL.md");
+      let oldSkillExists = false;
+      try {
+        await fs10.access(oldSkillPath);
+        oldSkillExists = true;
+      } catch {}
+      if (oldSkillExists) {
+        const message2 = "Found existing raggrep skill from previous installation.";
+        const locationMessage = `  Location: ${oldSkillPath}`;
+        if (logger) {
+          logger.info(message2);
+          logger.info(locationMessage);
+        } else {
+          console.log(message2);
+          console.log(locationMessage);
+        }
+        const readline = await import("readline");
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        const answer = await new Promise((resolve6) => {
+          rl.question("Remove the existing skill and install tool? (Y/n): ", resolve6);
+        });
+        rl.close();
+        const shouldDelete = answer.toLowerCase() !== "n";
+        if (shouldDelete) {
+          try {
+            await fs10.unlink(oldSkillPath);
+            const skillDirContents = await fs10.readdir(oldSkillDir);
+            if (skillDirContents.length === 0) {
+              try {
+                await fs10.rmdir(oldSkillDir);
+                console.log("✓ Removed old skill directory.");
+              } catch (rmdirError) {
+                console.log("✓ Removed old skill file. (Directory not empty or other error)");
+              }
+            } else {
+              console.log("✓ Removed old skill file. (Directory not empty, keeping structure)");
+            }
+            removedOldSkill = true;
+            const successMessage = "✓ Removed old skill file.";
+            if (logger) {
+              logger.info(successMessage);
+            } else {
+              console.log(successMessage);
+            }
+          } catch (error) {
+            const warnMessage = `Warning: Could not remove old skill file: ${error}`;
+            if (logger) {
+              logger.warn(warnMessage);
+            } else {
+              console.warn(warnMessage);
+            }
+          }
+        } else {
+          const keepMessage = "Keeping existing skill. Tool installation cancelled.";
+          if (logger) {
+            logger.info(keepMessage);
+          } else {
+            console.log(keepMessage);
+          }
+          return {
+            success: false,
+            message: keepMessage
+          };
+        }
+      }
+    }
+    await fs10.mkdir(toolDir, { recursive: true });
+    await fs10.writeFile(toolPath, toolContent, "utf-8");
+    const message = `Installed raggrep tool for OpenCode.
+  Location: ${toolPath}
+
+The raggrep tool is now available in OpenCode.`;
+    if (logger) {
+      logger.info(message);
+    } else {
+      console.log(message);
+    }
+    return {
+      success: true,
+      toolPath,
+      message,
+      removedOldSkill
+    };
+  } catch (error) {
+    const message = `Error installing OpenCode tool: ${error}`;
+    if (logger) {
+      logger.error(message);
+    } else {
+      console.error(message);
+    }
+    return {
+      success: false,
+      message
+    };
+  }
+}
+
+// src/app/cli/opencode/install-skill.ts
+async function installSkill(options = {}) {
+  const { logger, checkForOldTool = true } = options;
+  const os4 = await import("os");
+  const fs10 = await import("fs/promises");
+  const path25 = await import("path");
+  const homeDir = os4.homedir();
+  const skillDir = path25.join(homeDir, ".config", "opencode", "skill", "raggrep");
+  const skillPath = path25.join(skillDir, "SKILL.md");
+  const skillContent = `---
+name: raggrep
+description: AST-powered semantic code search that understands intent, not just text. Superior to grep/rg - finds functions, classes, and logic even when keywords differ. Saves 10x tool calls by searching the actual code structure.
+license: MIT
+compatibility: opencode
+metadata:
+  audience: developers
+  use_case: code-discovery
+---
+
+## What I do
+
+I'm a **MUCH better alternative to grep/rg** for code search. I provide semantic search that actually **understands your code** rather than just matching text:
+
+- **Parse code using AST** to extract functions, classes, variables, and symbols with full context
+- **Understand code structure** and relationships across files
+- **Search by intent** - find "authentication logic" even if the code uses "auth", "login", "verifyToken", etc.
+- **Find relevant code** even when exact keywords don't appear anywhere in the source
+- **Save ~10x tool calls** compared to manually reading files or using grep
+
+## When to use me
+
+Use me when you need to:
+- **Find WHERE code is located** (functions, components, services)
+- **Understand HOW code is structured** (architecture, patterns, dependencies)  
+- **Discover RELATED code** across multiple files
+- **Get a QUICK overview** of a topic or feature area
+
+## How to use me
+
+First, install raggrep if not already available:
+\`\`\`bash
+# Install raggrep globally
+npm install -g raggrep
+# or
+pnpm add -g raggrep
+\`\`\`
+
+### Step 1: Index your codebase
+\`\`\`bash
+# Navigate to your project directory and index it
+cd /path/to/your/project
+raggrep index
+\`\`\`
+
+### Step 2: Use semantic search
+\`\`\`bash
+# Search for specific functionality
+raggrep query "user authentication"
+
+# Search with filters
+raggrep query "React hooks for data fetching" --filter "src/components"
+
+# Search with specific file types
+raggrep query "database connection" --type ts
+
+# Get more results
+raggrep query "error handling" --top 15
+\`\`\`
+
+### Step 3: Use in OpenCode agents
+
+Load this skill in your agent conversation:
+\`\`\`
+skill({ name: "raggrep" })
+\`\`\`
+
+Then the agent can use raggrep commands to search your codebase efficiently.
+
+## Why I'm Better Than grep/rg
+
+❌ **grep/rg limitations:**
+- Only matches literal text patterns
+- Can't understand code structure or intent  
+- Requires exact keyword matches
+- Often returns irrelevant results
+
+✅ **My advantages:**
+- Understands code semantics and intent
+- Finds relevant code even with different terminology
+- Works with AST-extracted symbols, not just raw text
+- Provides contextual, ranked results
+
+## Search Examples
+
+Instead of using grep/rg or manually reading files:
+
+❌ **DON'T do this:**
+- \`rg "auth" --type ts\` (might miss middleware, login, verifyToken)
+- Read: auth.ts, middleware.ts, index.ts to find auth logic
+- Read: App.tsx, components/*, pages/* to find React components  
+- Read: db.ts, config.ts, models/* to find database code
+
+✅ **DO this instead:**
+- \`raggrep query "Find the auth middleware"\` (finds ALL auth-related code)
+- \`raggrep query "Where are React components?"\`
+- \`raggrep query "Database connection logic?"\`
+- \`raggrep query "Error handling patterns"\`
+
+## Best Practices
+
+1. **Think intent, not keywords**: "user authentication logic" works better than \`rg "auth"\`
+2. **Use filters strategically**: \`--filter "src/auth"\`, \`--filter "*.test.ts"\`
+3. **Adjust result count**: Use \`--top 5\` for focused results, \`--top 20\` for comprehensive search
+4. **Replace grep/rg habits**: Instead of \`rg "pattern"\`, try \`raggrep query "what the code does"\`
+
+**Result**: 10x fewer tool calls, BETTER results, deeper code understanding.
+`;
+  let removedOldTool = false;
+  try {
+    if (checkForOldTool) {
+      const oldToolDir = path25.join(homeDir, ".config", "opencode", "tool");
+      const oldToolPath = path25.join(oldToolDir, "raggrep.ts");
+      let oldToolExists = false;
+      try {
+        await fs10.access(oldToolPath);
+        oldToolExists = true;
+      } catch {}
+      if (oldToolExists) {
+        const message2 = "Found old raggrep tool file from previous version.";
+        const locationMessage = `  Location: ${oldToolPath}`;
+        if (logger) {
+          logger.info(message2);
+          logger.info(locationMessage);
+        } else {
+          console.log(message2);
+          console.log(locationMessage);
+        }
+        const readline = await import("readline");
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        const answer = await new Promise((resolve6) => {
+          rl.question("Do you want to remove the old tool file? (Y/n): ", resolve6);
+        });
+        rl.close();
+        const shouldDelete = answer.toLowerCase() !== "n";
+        if (shouldDelete) {
+          try {
+            await fs10.unlink(oldToolPath);
+            const toolDirContents = await fs10.readdir(oldToolDir);
+            if (toolDirContents.length === 0) {
+              try {
+                await fs10.rmdir(oldToolDir);
+                console.log("✓ Removed old tool directory.");
+              } catch (rmdirError) {
+                console.log("✓ Removed old tool file. (Directory not empty or other error)");
+              }
+            } else {
+              console.log("✓ Removed old tool file. (Directory not empty, keeping structure)");
+            }
+            removedOldTool = true;
+            const successMessage = "✓ Removed old tool file.";
+            if (logger) {
+              logger.info(successMessage);
+            } else {
+              console.log(successMessage);
+            }
+          } catch (error) {
+            const warnMessage = `Warning: Could not remove old tool file: ${error}`;
+            if (logger) {
+              logger.warn(warnMessage);
+            } else {
+              console.warn(warnMessage);
+            }
+          }
+        } else {
+          const keepMessage = "Keeping old tool file.";
+          if (logger) {
+            logger.info(keepMessage);
+          } else {
+            console.log(keepMessage);
+          }
+        }
+      }
+    }
+    await fs10.mkdir(skillDir, { recursive: true });
+    await fs10.writeFile(skillPath, skillContent, "utf-8");
+    const message = `Installed raggrep skill for OpenCode.
+  Location: ${skillPath}
+
+The raggrep skill is now available to OpenCode agents.
+
+To use this skill:
+1. Install raggrep: npm install -g raggrep
+2. Index your codebase: raggrep index
+3. In OpenCode, load the skill: skill({ name: "raggrep" })`;
+    if (logger) {
+      logger.info(message);
+    } else {
+      console.log(message);
+    }
+    return {
+      success: true,
+      skillPath,
+      message,
+      removedOldTool
+    };
+  } catch (error) {
+    const message = `Error installing OpenCode skill: ${error}`;
+    if (logger) {
+      logger.error(message);
+    } else {
+      console.error(message);
+    }
+    return {
+      success: false,
+      message
+    };
+  }
+}
+
+// src/app/cli/opencode/index.ts
+var exports_opencode = {};
+__export(exports_opencode, {
+  supportsSkills: () => supportsSkills,
+  parseOpenCodeVersion: () => parseOpenCodeVersion,
+  installTool: () => installTool,
+  installSkill: () => installSkill,
+  getInstallationMethod: () => getInstallationMethod,
+  detectOpenCodeVersion: () => detectOpenCodeVersion
+});
+var init_opencode = () => {};
+
 // src/app/cli/main.ts
 init_embeddings();
 init_logger();
 // package.json
 var package_default = {
   name: "raggrep",
-  version: "0.12.3",
+  version: "0.13.2",
   description: "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   type: "module",
   main: "./dist/index.js",
@@ -14593,6 +15147,8 @@ function parseFlags(args3) {
     verbose: false,
     watch: false,
     timing: false,
+    forceTool: false,
+    forceSkill: false,
     remaining: []
   };
   for (let i2 = 0;i2 < args3.length; i2++) {
@@ -14654,6 +15210,10 @@ function parseFlags(args3) {
         console.error('--filter requires a path or glob pattern (e.g., src/auth, "*.ts")');
         process.exit(1);
       }
+    } else if (arg === "--tool") {
+      flags2.forceTool = true;
+    } else if (arg === "--skill") {
+      flags2.forceSkill = true;
     } else if (!arg.startsWith("-")) {
       flags2.remaining.push(arg);
     }
@@ -14970,129 +15530,76 @@ Examples:
       const subcommand = flags2.remaining[0];
       if (flags2.help || !subcommand) {
         console.log(`
-raggrep opencode - Manage opencode integration
+raggrep opencode - Manage OpenCode integration
 
 Usage:
-  raggrep opencode <subcommand>
+  raggrep opencode <subcommand> [options]
 
 Subcommands:
-  install    Install or update the raggrep tool for opencode
+  install    Install or update raggrep for OpenCode
+
+Options:
+  --tool     Force tool-based installation (default)
+  --skill    Force skill-based installation
 
 Description:
-  Installs the raggrep tool to ~/.config/opencode/tool/raggrep.ts
-  This allows opencode to use raggrep for semantic code search.
+  Installs raggrep for OpenCode with mutual exclusivity:
+  - Tool installation (default): ~/.config/opencode/tool/raggrep.ts
+  - Skill installation: ~/.config/opencode/skill/raggrep/SKILL.md
+  Installing one will prompt to remove the other (default: yes)
 
 Examples:
-  raggrep opencode install
+  raggrep opencode install          # Install tool (default)
+  raggrep opencode install --tool   # Force tool installation
+  raggrep opencode install --skill  # Force skill installation
 `);
         process.exit(0);
       }
       if (subcommand === "install") {
-        const os4 = await import("os");
-        const fs10 = await import("fs/promises");
-        const path25 = await import("path");
-        const homeDir = os4.homedir();
-        const toolDir = path25.join(homeDir, ".config", "opencode", "tool");
-        const toolPath = path25.join(toolDir, "raggrep.ts");
-        const toolContent = `import { tool } from "@opencode-ai/plugin";
-
-/**
- * Get the package executor command (pnpx if available, otherwise npx)
- */
-async function getExecutor(): Promise<string> {
-  try {
-    // Try to find pnpm first (faster)
-    await Bun.spawn(['pnpm', '--version'], { stdout: 'pipe', stderr: 'pipe' }).exited;
-    return 'pnpx';
-  } catch {
-    // Fall back to npx
-    return 'npx';
-  }
-}
-
-/**
- * Get the installed raggrep version
- */
-async function getRagrepVersion(executor: string): Promise<string | null> {
-  try {
-    const proc = Bun.spawn([executor, 'raggrep', '--version'], { stdout: 'pipe', stderr: 'pipe' });
-    const output = await new Response(proc.stdout).text();
-    const match = output.match(/v([\\d.]+)/);
-    return match ? match[1] : null;
-  } catch {
-    return null;
-  }
-}
-
-export default tool({
-  description:
-    "Semantic code search powered by RAG - understands INTENT, not just literal text. Parses code using AST to extract functions, classes, and symbols with full context. Finds relevant code even when exact keywords don't match. Superior to grep for exploratory searches like 'authentication logic', 'error handling patterns', or 'configuration loading'.\\n\\n\uD83C\uDFAF USE THIS TOOL FIRST when you need to:\\n• Find WHERE code is located (functions, components, services)\\n• Understand HOW code is structured\\n• Discover RELATED code across multiple files\\n• Get a QUICK overview of a topic\\n\\n❌ DON'T read multiple files manually when you can:\\n  raggrep(\\"user authentication\\", { filter: [\\"src/\\"] })\\n\\n✅ INSTEAD of reading files one-by-one, search semantically:\\n  • \\"Find the auth middleware\\" vs read: auth.ts, middleware.ts, index.ts...\\n  • \\"Where are React components?\\" vs read: App.tsx, components/*, pages/*...\\n  • \\"Database connection logic?\\" vs read: db.ts, config.ts, models/*...\\n  • \\"Error handling patterns\\" vs read: error.ts, middleware.ts, handlers/*...\\n\\nThis saves ~10x tool calls and provides BETTER context by showing related code across the entire codebase.",
-  args: {
-    query: tool.schema
-      .string()
-      .describe(
-        "Natural language search query describing what you want to find. Be specific: 'auth middleware that checks JWT', 'React hooks for data fetching', 'database connection pool config'. This is MUCH faster than reading files manually."
-      ),
-    filter: tool.schema
-      .array(tool.schema.string())
-      .describe(
-        "Array of path prefixes or glob patterns to narrow search scope (OR logic). If user mentions a directory, use it. Otherwise infer from context. Common patterns: ['src/auth'], ['*.tsx', 'components/'], ['api/', 'routes/'], ['docs/', '*.md'], ['*.test.ts']. For broad search use ['src/'] or ['**/*']."
-      ),
-    top: tool.schema
-      .number()
-      .optional()
-      .describe("Number of results to return (default: 10)"),
-    minScore: tool.schema
-      .number()
-      .optional()
-      .describe("Minimum similarity score 0-1 (default: 0.15)"),
-    type: tool.schema
-      .string()
-      .optional()
-      .describe(
-        "Filter by single file extension without dot (e.g., 'ts', 'tsx', 'js', 'md'). Prefer using 'filter' with glob patterns like '*.ts' for more flexibility."
-      ),
-  },
-  async execute(args) {
-    const executor = await getExecutor();
-    const version = await getRagrepVersion(executor);
-
-    if (!version) {
-      return \`Error: raggrep not found. Install it with: \${executor} install -g raggrep\`;
-    }
-
-    const cmdArgs = [args.query];
-
-    if (args.top !== undefined) {
-      cmdArgs.push("--top", String(args.top));
-    }
-    if (args.minScore !== undefined) {
-      cmdArgs.push("--min-score", String(args.minScore));
-    }
-    if (args.type !== undefined) {
-      cmdArgs.push("--type", args.type);
-    }
-    if (args.filter !== undefined && args.filter.length > 0) {
-      for (const f of args.filter) {
-        cmdArgs.push("--filter", f);
-      }
-    }
-
-    const proc = Bun.spawn([executor, 'raggrep', 'query', ...cmdArgs], { stdout: 'pipe' });
-    const result = await new Response(proc.stdout).text();
-    return result.trim();
-  },
-});
-`;
+        if (flags2.forceTool && flags2.forceSkill) {
+          console.error("Error: --tool and --skill flags are mutually exclusive");
+          process.exit(1);
+        }
+        const {
+          detectOpenCodeVersion: detectOpenCodeVersion2,
+          getInstallationMethod: getInstallationMethod2,
+          installTool: installTool2,
+          installSkill: installSkill2
+        } = await Promise.resolve().then(() => (init_opencode(), exports_opencode));
         try {
-          await fs10.mkdir(toolDir, { recursive: true });
-          await fs10.writeFile(toolPath, toolContent, "utf-8");
-          console.log(`Installed raggrep tool for opencode.`);
-          console.log(`  Location: ${toolPath}`);
+          let method;
+          if (flags2.forceTool) {
+            method = "tool";
+          } else if (flags2.forceSkill) {
+            method = "skill";
+          } else {
+            method = "tool";
+          }
+          console.log("RAGgrep OpenCode Installer");
+          console.log(`==========================
+`);
+          if (flags2.forceTool) {
+            console.log("Forced tool-based installation (--tool flag)");
+          } else if (flags2.forceSkill) {
+            console.log("Forced skill-based installation (--skill flag)");
+          } else {
+            console.log("Default tool-based installation");
+          }
+          console.log(`Installing ${method}...
+`);
+          let result;
+          if (method === "tool") {
+            result = await installTool2({ checkForOldSkill: true });
+          } else {
+            result = await installSkill2({ checkForOldTool: true });
+          }
+          if (!result.success) {
+            process.exit(1);
+          }
           console.log(`
-The raggrep tool is now available in opencode.`);
+Installation completed successfully!`);
         } catch (error) {
-          console.error("Error installing opencode tool:", error);
+          console.error("Error during installation:", error);
           process.exit(1);
         }
       } else {
@@ -15137,4 +15644,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=0D7443A2D252636E64756E2164756E21
+//# debugId=5CD6138213DBFFD864756E2164756E21