opencoder

import { tool, type Tool, type ToolsProviderController } from "@lmstudio/sdk";
import { z } from "zod";
import { existsSync, mkdirSync } from "fs";
import { writeFile, readFile } from "fs/promises";
import { dirname, join } from "path";

/**
 * Walidator i czyściciel frontmattera
 * Usuwa pola 'name' i 'trigger', zostawia tylko dozwolone.
 */
function refineFrontmatter(rawContent: string, description?: string): { cleanContent: string, frontmatter: any } {
  const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
  const match = rawContent.match(frontmatterRegex);
  
  let fm: any = {};
  let body = rawContent;

  if (match) {
    const fmText = match[1];
    body = rawContent.replace(frontmatterRegex, "").trim();
    
    // Prosty parser YAML (klucz: wartość)
    fmText.split("\n").forEach(line => {
      const [key, ...valParts] = line.split(":");
      if (key && valParts.length > 0) {
        const k = key.trim().toLowerCase();
        const v = valParts.join(":").trim().replace(/^["']|["']$/g, "");
        
        // Tylko dozwolone pola
        if (["description", "agent", "model", "subtask"].includes(k)) {
          fm[k] = v;
        }
      }
    });
  }

  if (description && !fm.description) fm.description = description;
  
  const cleanFmLines = ["---"];
  if (fm.description) cleanFmLines.push(`description: "${fm.description}"`);
  if (fm.agent) cleanFmLines.push(`agent: ${fm.agent}`);
  if (fm.model) cleanFmLines.push(`model: ${fm.model}`);
  if (fm.subtask !== undefined) cleanFmLines.push(`subtask: ${fm.subtask}`);
  cleanFmLines.push("---");

  return {
    cleanContent: cleanFmLines.join("\n") + "\n\n" + body,
    frontmatter: fm
  };
}

export async function toolsProvider(ctl: ToolsProviderController): Promise<Tool[]> {
  const refineOpencodeCommand = tool({
    name: "refine_opencode_command",
    description: `You are the Opencoder Expert. Your mission is to transform raw user ideas into professional, high-performance OpenCode command templates.

REFINEMENT PHILOSOPHY:
- Don't just copy the user's text. Engineer it into a deterministic system.
- Use a Phase-based architecture (e.g., PHASE 0: INTENT GATE, PHASE 1: ANALYSIS).
- Incorporate explicit verification strategies (LSP diagnostics, test suite execution, regression checks).
- Use professional, technical SF-Bay-Area-style English.
- Leverage OpenCode-specific syntax: $ARGUMENTS, $1, @path/to/file, \`!\`bash_command\`\`.

OPERATIONAL PROTOCOL FOR REFINEMENT:
1. PHASE 0 (INTENT GATE): Mandatory first step to classify, validate, and confirm understanding of the request.
2. PARALLEL EXPLORATION: Define steps to launch multiple 'explore' agents in background to map the codebase.
3. CODEMAP & IMPACT: Include logic to build a dependency graph and identify impact zones.
4. TEST ASSESSMENT: Analyze existing test infrastructure and block/pause if coverage is insufficient.
5. DETERMINISTIC EXECUTION: Use LSP (rename, definitions) and AST-grep (structural patterns) instead of blind text edits.
6. CONTINUOUS VERIFICATION: Mandate running diagnostics and tests after EVERY atomic change.
7. CLEAN FRONTMATTER: Use only 'description', 'agent', 'model', 'subtask'. Strictly remove 'name' or 'trigger'.

OUTPUT STRUCTURE:
- Suggested Filename: kebab-case (e.g., 'smart-refactor.md').
- Content: A complete Markdown file starting with --- frontmatter --- followed by the <command-instruction> block.

EXAMPLE REFINEMENT TARGET:
"Zrób komendę do refaktoryzacji starych komponentów w React na funkcjonalne"
Refined Result:
---
description: "Intelligently refactor class components to functional components using AST-grep"
agent: build
---
<command-instruction>
# React Functional Refactor
## PHASE 0: INTENT GATE
Check if the target component is a class component...
## PHASE 1: ANALYSIS
Launch parallel explore agents to find all lifecycle methods...
...
</command-instruction>`,
    parameters: {
      refined_content: z.string().describe("The COMPLETE, engineered markdown content (Frontmatter + <command-instruction> block) in Technical English."),
      suggested_filename: z.string().describe("Suggested kebab-case filename (e.g., spark-brainstorm.md)"),
      force_save: z.boolean().default(false).describe("Whether to persist the file to the commands directory.")
    },
    implementation: async ({ refined_content, suggested_filename, force_save }) => {
      try {
        const { cleanContent } = refineFrontmatter(refined_content);
        
        let fileName = suggested_filename;
        if (!fileName.endsWith(".md")) fileName += ".md";

        if (force_save) {
          const workingDir = ctl.getWorkingDirectory();
          const commandsDir = join(workingDir, "commands");
          if (!existsSync(commandsDir)) mkdirSync(commandsDir, { recursive: true });
          
          await writeFile(join(commandsDir, fileName), cleanContent, "utf-8");
        }

        return `✅ OPENCORDER: MISSION ACCOMPLISHED
File: ${fileName}
Status: ${force_save ? "Persisted to /commands" : "Draft Generated"}

---
${cleanContent}`;
      } catch (error) {
        return `❌ OPENCORDER ERROR: ${error instanceof Error ? error.message : String(error)}`;
      }
    },
  });

  return [refineOpencodeCommand];
}