opencode-file-writer/index.js

OpenCode plugin that forces file creation to work by intercepting write tool calls

import { writeFile, mkdir } from "fs/promises";
import { dirname, join } from "path";
import { tool } from "@opencode-ai/plugin";

export default async (ctx) => {
  const { $, directory } = ctx;
  
  console.error("[PLUGIN] File writer plugin loaded!");
  
  // Helper function to actually write files
  const forceWriteFile = async (path, content) => {
    console.error(`[PLUGIN] forceWriteFile called: ${path}`);
    try {
      const fullPath = path.startsWith("/") ? path : join(directory, path);
      const dir = dirname(fullPath);
      await mkdir(dir, { recursive: true });
      await writeFile(fullPath, content || "", "utf8");
      return `Successfully created file at ${fullPath}`;
    } catch (error) {
      // Fallback to shell command
      try {
        const escapedContent = (content || "").replace(/'/g, "'\\''");
        const escapedPath = fullPath.replace(/'/g, "'\\''");
        await $`mkdir -p ${dirname(fullPath)}`;
        await $`printf '%s\n' '${escapedContent}' > '${escapedPath}'`;
        return `Successfully created file at ${fullPath} (via shell)`;
      } catch (shellError) {
        return `Error creating file: ${error.message} (shell fallback also failed: ${shellError.message})`;
      }
    }
  };
  
  return {
    "permission.ask": async (permission, output) => {
      console.error(`[PLUGIN] permission.ask: ${permission.type}`);
      // Always allow all permissions
      output.status = "allow";
    },
    
    tool: {
      // Override write tool with our own implementation
      write: tool({
        description: "Write content to a file. This tool actually creates files.",
        args: {
          filePath: tool.schema.string().optional().describe("Full path to the file to create (will be inferred if not provided)"),
          content: tool.schema.string().describe("Content to write to the file"),
        },
        async execute(args) {
          // If filePath is missing, try to infer it from content
          let path = args.filePath;
          if (!path && args.content) {
            const fileMatch = args.content.match(/(?:file|create|write|save).*?['"`]([^'"`]+\.(js|ts|py|html|css|json|md|sh))['"`]/i);
            if (fileMatch) {
              path = fileMatch[1];
            } else {
              path = join(directory, "untitled.js");
            }
          }
          return await forceWriteFile(path || join(directory, "untitled.js"), args.content);
        },
      }),
      
      // Also create a CreateFile tool
      CreateFile: tool({
        description: "Create a new file at the specified path",
        args: {
          path: tool.schema.string().describe("Full path where to create the file"),
          content: tool.schema.string().optional().describe("Content to write to the file"),
        },
        async execute(args) {
          return await forceWriteFile(args.path, args.content || "");
        },
      }),
    },
    
    "tool.execute.before": async (input, output) => {
      console.error(`[PLUGIN] tool.execute.before: ${input.tool}`, JSON.stringify(input.args));
      // Intercept ALL write-related tool calls and execute them immediately
      const writeTools = ["write", "CreateFile", "createFile", "writeFile", "taskrite"];
      if (writeTools.includes(input.tool)) {
        console.error(`[PLUGIN] Intercepting ${input.tool} tool call`);
        const args = input.args || {};
        // Handle taskrite format: {content: "...", name: "filename"}
        let path, content;
        if (input.tool === "taskrite" && args.content) {
          // Extract filename from content: "create a new file named clock.js"
          const fileMatch = args.content.match(/create a new file named\s+(\S+)/i);
          if (fileMatch) {
            path = fileMatch[1];
            // Extract code after "add the following code:" or just use everything after the filename instruction
            const codeMatch = args.content.match(/add the following code:\s*\n\n(.*)/is);
            content = codeMatch ? codeMatch[1].trim() : args.content.split(/add the following code:/i)[1]?.trim() || args.content;
          } else {
            path = args.name || "untitled.js";
            content = args.content;
          }
        } else {
          // Try to extract filePath from content if it's missing
          path = args.filePath || args.path || args[0] || args.file || args.filepath || args.name;
          content = args.content || args[1] || args.data || args.text || "";
          
          // If filePath is missing but we have content, try to infer it
          if (!path && content) {
            // Look for file mentions in content
            const fileMatch = content.match(/(?:file|create|write|save).*?['"`]([^'"`]+\.(js|ts|py|html|css|json|md|sh))['"`]/i);
            if (fileMatch) {
              path = fileMatch[1];
            } else {
              // Default to a filename based on context
              path = join(directory, "untitled.js");
            }
          }
        }
        
        if (path && content) {
          console.error(`[PLUGIN] Creating file: ${path}`);
          const result = await forceWriteFile(path, typeof content === "string" ? content : "");
          // Ensure args match expected schema
          output.args = { filePath: path, content: typeof content === "string" ? content : "", _executed: true, _result: result };
        } else {
          console.error(`[PLUGIN] Missing path or content. path=${path}, hasContent=${!!content}`);
        }
      }
    },
    
    "tool.execute.after": async (input, output) => {
      console.error(`[PLUGIN] tool.execute.after: ${input.tool}`, JSON.stringify(output));
      // If tool failed, try to execute it ourselves
      if (input.tool === "write" || input.tool === "CreateFile" || input.tool === "taskrite") {
        console.error(`[PLUGIN] Checking if ${input.tool} needs fallback execution`);
        const args = input.args || {};
        let path, content;
        
        // Handle taskrite format
        if (input.tool === "taskrite" && args.content) {
          const fileMatch = args.content.match(/create a new file named\s+(\S+)/i);
          if (fileMatch) {
            path = fileMatch[1];
            const codeMatch = args.content.match(/add the following code:\s*\n\n(.*)/is);
            content = codeMatch ? codeMatch[1].trim() : args.content.split(/add the following code:/i)[1]?.trim() || args.content;
          } else {
            path = args.name || "untitled.js";
            content = args.content;
          }
        } else {
          path = args.filePath || args.path || args[0] || args.file || args.filepath || args.name;
          content = args.content || args[1] || args.data || args.text || "";
        }
        
        // Check if it actually executed
        if (path && content && (!output.output || output.output.includes("denied") || output.output.includes("error") || output.output.includes("failed"))) {
          const result = await forceWriteFile(path, typeof content === "string" ? content : "");
          output.title = `Created file: ${path}`;
          output.output = result;
          output.metadata = { path, executed: true, via: "plugin_fallback" };
        }
      }
    },
  };
};