project_opencode.go

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
)

// OpenCodeProjector generates OpenCode platform files.
// OpenCode reads .claude/ dirs natively, so projectClaudeDir handles shared output.
// It also has its own .opencode/ directory for native skills/agents.
type OpenCodeProjector struct{}

func (p *OpenCodeProjector) Name() string { return "opencode" }

func (p *OpenCodeProjector) OutputPaths(rules, skills, agents []string, hasMCP bool) []string {
	// OpenCode shares .claude/ directory + has its own .opencode/
	paths := []string{"AGENTS.md", ".opencode/plugins/lore-hooks.mjs"}
	if hasMCP {
		paths = append(paths, "opencode.json")
	}
	for _, n := range rules {
		paths = append(paths, ".claude/rules/"+n+".md")
	}
	for _, n := range skills {
		paths = append(paths, ".claude/skills/"+n+"/", ".claude/skills/"+n+"/SKILL.md")
		paths = append(paths, ".opencode/skills/"+n+"/", ".opencode/skills/"+n+"/SKILL.md")
		paths = append(paths, ".opencode/commands/"+n+".md")
	}
	for _, n := range agents {
		paths = append(paths, ".claude/agents/"+n+".md")
		paths = append(paths, ".opencode/agents/"+n+".md")
	}
	return paths
}

func (p *OpenCodeProjector) Project(root string, ms *MergedSet) error {
	// Shared .claude/ directory — OpenCode reads these natively
	if err := projectClaudeDir(root, ms); err != nil {
		return err
	}

	// Also project to .opencode/ native directories
	opencodeDir := filepath.Join(root, ".opencode")
	if err := projectSkills(opencodeDir, ms); err != nil {
		return err
	}
	if err := projectAgentsRecord(opencodeDir, ms); err != nil {
		return err
	}

	// AGENTS.md at root (OpenCode mandate file)
	if err := writeAGENTSMD(root, ms); err != nil {
		return err
	}

	// MCP: OpenCode expects MCP servers in opencode.json under "mcp".
	if len(ms.MCP) > 0 {
		if err := p.writeMCPConfig(root, ms.MCP); err != nil {
			return err
		}
	}

	// User-invocable skills → .opencode/commands/<name>.md (OpenCode slash commands)
	// $ARGUMENTS is already the native OpenCode convention.
	for _, skill := range userInvocableSkills(ms) {
		fm := map[string]interface{}{}
		if skill.Description != "" {
			fm["description"] = skill.Description
		}
		content := renderFrontmatter(fm) + "\n" + skill.Body + "\n"
		path := filepath.Join(root, ".opencode", "commands", skill.Name+".md")
		if err := writeFile(path, []byte(content)); err != nil {
			return fmt.Errorf("write opencode command %s: %w", skill.Name, err)
		}
	}

	// Hooks: OpenCode uses JS plugins, not JSON config.
	// Generate a stub plugin that shells out to `lore hook`.
	return p.writeHookPlugin(root)
}

func (p *OpenCodeProjector) writeMCPConfig(root string, servers []MCPServer) error {
	configPath := filepath.Join(root, "opencode.json")

	config := map[string]interface{}{}
	if data, err := os.ReadFile(configPath); err == nil {
		cleaned := stripJSONComments(data)
		if err := json.Unmarshal(cleaned, &config); err != nil {
			return fmt.Errorf("parse opencode.json: %w", err)
		}
	}

	if _, ok := config["$schema"]; !ok {
		config["$schema"] = "https://opencode.ai/config.json"
	}

	merged := map[string]interface{}{}
	if raw, ok := config["mcp"]; ok {
		if existing, ok := raw.(map[string]interface{}); ok {
			for name, entry := range existing {
				merged[name] = entry
			}
		}
	}

	for _, s := range servers {
		command := make([]string, 0, 1+len(s.Args))
		command = append(command, s.Command)
		command = append(command, s.Args...)

		entry := map[string]interface{}{
			"type":    "local",
			"command": command,
			"enabled": true,
		}
		if len(s.Env) > 0 {
			entry["environment"] = s.Env
		}
		merged[s.Name] = entry
	}

	config["mcp"] = merged

	data, err := json.MarshalIndent(config, "", "  ")
	if err != nil {
		return fmt.Errorf("marshal opencode.json: %w", err)
	}
	if err := writeFile(configPath, append(data, '\n')); err != nil {
		return fmt.Errorf("write opencode.json: %w", err)
	}

	return nil
}

func (p *OpenCodeProjector) writeHookPlugin(root string) error {
	plugin := `// Lore hook plugin for OpenCode
// Generated by lore generate — do not edit manually.
import { execSync } from "child_process";

function loreHook(name, ctx) {
  try {
    const input = JSON.stringify(ctx);
    execSync("lore hook " + name, { input, stdio: ["pipe", "pipe", "inherit"] });
  } catch (_) {}
}

export default {
  name: "lore-hooks",

  hooks: {
    "tool.execute.before": (ctx) => loreHook("pre-tool-use", ctx),
    "tool.execute.after": (ctx) => loreHook("post-tool-use", ctx),
    "chat.message": (ctx) => loreHook("prompt-submit", ctx),
    "stop": (ctx) => loreHook("stop", ctx),
    "experimental.session.compacting": (ctx) => loreHook("pre-compact", ctx),
  },

  event: (event) => {
    if (event.type === "session.created") loreHook("session-start", event);
    if (event.type === "session.deleted") loreHook("session-end", event);
  },
};
`
	path := filepath.Join(root, ".opencode", "plugins", "lore-hooks.mjs")
	if err := writeFile(path, []byte(plugin)); err != nil {
		return fmt.Errorf("write opencode hook plugin: %w", err)
	}
	return nil
}