feat: refactor command loading and enhance command definitions with frontmatter parsing

Author: Helweg

commands/find.md

@@ -2,12 +2,24 @@
 description: Find code using hybrid approach (semantic + grep)
 ---
 
-Find code related to: $ARGUMENTS
+Find code using both semantic search and grep.
+
+User input: $ARGUMENTS
 
 Strategy:
-1. First use `codebase_search` to find semantically related code
-2. From the results, identify specific function/class names
+1. Use `codebase_search` to find semantically related code
+2. Identify specific function/class/variable names from results
 3. Use grep to find all occurrences of those identifiers
-4. Combine findings into a comprehensive answer
+4. Combine into a comprehensive answer
+
+Parse optional parameters from input:
+- `limit=N` → limit semantic results
+- `type=X` or "functions"/"classes" → filter chunk type
+- `dir=X` → filter directory
+
+Examples:
+- `/find error handling middleware`
+- `/find payment validation type=function`
+- `/find user auth in src/services`
 
-If the semantic index doesn't exist, run `index_codebase` first.
+If no index exists, run `index_codebase` first.

commands/index.md

@@ -2,10 +2,20 @@
 description: Index the codebase for semantic search
 ---
 
-Run the `index_codebase` tool to create or update the semantic search index.
+Run the `index_codebase` tool with these settings:
 
-Show progress and final statistics including:
-- Number of files processed
-- Number of chunks indexed
-- Tokens used
-- Duration
+User input: $ARGUMENTS
+
+Parse the input and set tool arguments:
+- force=true if input contains "force"
+- estimateOnly=true if input contains "estimate" 
+- verbose=true (always, for detailed output)
+
+Examples:
+- `/index` → force=false, estimateOnly=false, verbose=true
+- `/index force` → force=true, estimateOnly=false, verbose=true
+- `/index estimate` → force=false, estimateOnly=true, verbose=true
+
+IMPORTANT: You MUST pass the parsed arguments to `index_codebase`. Do not ignore them.
+
+Show final statistics including files processed, chunks indexed, tokens used, and duration.

commands/search.md

@@ -2,8 +2,23 @@
 description: Search codebase by meaning using semantic search
 ---
 
-Use the `codebase_search` tool to find code related to: $ARGUMENTS
+Search the codebase using semantic search.
 
-If the index doesn't exist yet, run `index_codebase` first.
+User input: $ARGUMENTS
 
-Return the most relevant results with file paths and line numbers.
+The first part is the search query. Look for optional parameters:
+- `limit=N` or "top N" or "first N" → set limit
+- `type=X` or mentions "functions"/"classes"/"methods" → set chunkType
+- `dir=X` or "in folder X" → set directory filter
+- File extensions like ".ts", "typescript", ".py" → set fileType
+
+Call `codebase_search` with the parsed arguments.
+
+Examples:
+- `/search authentication logic` → query="authentication logic"
+- `/search error handling limit=5` → query="error handling", limit=5
+- `/search validation functions` → query="validation", chunkType="function"
+
+If the index doesn't exist, run `index_codebase` first.
+
+Return results with file paths and line numbers.

src/commands/loader.ts

@@ -0,0 +1,56 @@
+import { existsSync, readdirSync, readFileSync } from "fs";
+import * as path from "path";
+
+export interface CommandDefinition {
+  description: string;
+  template: string;
+}
+
+function parseFrontmatter(content: string): { frontmatter: Record<string, string>; body: string } {
+  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  
+  if (!match) {
+    return { frontmatter: {}, body: content.trim() };
+  }
+
+  const frontmatterLines = match[1].split("\n");
+  const frontmatter: Record<string, string> = {};
+  
+  for (const line of frontmatterLines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      frontmatter[key] = value;
+    }
+  }
+
+  return { frontmatter, body: match[2].trim() };
+}
+
+export function loadCommandsFromDirectory(commandsDir: string): Map<string, CommandDefinition> {
+  const commands = new Map<string, CommandDefinition>();
+
+  if (!existsSync(commandsDir)) {
+    return commands;
+  }
+
+  const files = readdirSync(commandsDir).filter((f) => f.endsWith(".md"));
+
+  for (const file of files) {
+    const filePath = path.join(commandsDir, file);
+    const content = readFileSync(filePath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(content);
+    
+    const name = path.basename(file, ".md");
+    const description = frontmatter.description || `Run the ${name} command`;
+
+    commands.set(name, {
+      description,
+      template: body,
+    });
+  }
+
+  return commands;
+}

src/index.ts

@@ -2,6 +2,7 @@ import type { Plugin } from "@opencode-ai/plugin";
 import { existsSync, readFileSync } from "fs";
 import * as path from "path";
 import * as os from "os";
+import { fileURLToPath } from "url";
 
 import { parseConfig } from "./config/schema.js";
 import { Indexer } from "./indexer/index.js";
@@ -13,6 +14,17 @@ import {
   index_health_check,
   initializeTools,
 } from "./tools/index.js";
+import { loadCommandsFromDirectory } from "./commands/loader.js";
+
+function getCommandsDir(): string {
+  let currentDir = process.cwd();
+  
+  if (typeof import.meta !== "undefined" && import.meta.url) {
+    currentDir = path.dirname(fileURLToPath(import.meta.url));
+  }
+  
+  return path.join(currentDir, "..", "commands");
+}
 
 function loadJsonFile(filePath: string): unknown {
   try {
@@ -69,38 +81,12 @@ const plugin: Plugin = async ({ directory }) => {
     async config(cfg) {
       cfg.command = cfg.command ?? {};
 
-      cfg.command["search"] = {
-        description: "Search codebase by meaning using semantic search",
-        template: `Use the \`codebase_search\` tool to find code related to: $ARGUMENTS
-
-If the index doesn't exist yet, run \`index_codebase\` first.
-
-Return the most relevant results with file paths and line numbers.`,
-      };
-
-      cfg.command["find"] = {
-        description: "Find code using hybrid approach (semantic + grep)",
-        template: `Find code related to: $ARGUMENTS
-
-Strategy:
-1. First use \`codebase_search\` to find semantically related code
-2. From the results, identify specific function/class names
-3. Use grep to find all occurrences of those identifiers
-4. Combine findings into a comprehensive answer
-
-If the semantic index doesn't exist, run \`index_codebase\` first.`,
-      };
-
-      cfg.command["index"] = {
-        description: "Index the codebase for semantic search",
-        template: `Run the \`index_codebase\` tool to create or update the semantic search index.
+      const commandsDir = getCommandsDir();
+      const commands = loadCommandsFromDirectory(commandsDir);
 
-Show progress and final statistics including:
-- Number of files processed
-- Number of chunks indexed
-- Tokens used
-- Duration`,
-      };
+      for (const [name, definition] of commands) {
+        cfg.command[name] = definition;
+      }
     },
   };
 };