feat: add OpenCode plugin support

Add --opencode flag to 'openwolf init' for registering OpenCode plugin
instead of Claude Code hooks.

- Create OpenCode plugin directory with separated modules:
  - types.ts: interfaces for SessionState, FileRead, FileWrite, etc.
  - fs.ts: file system helpers (readJSON, writeJSON, etc.)
  - anatomy.ts: anatomy.md parsing and serialization
  - session.ts: session start handling
  - pre-read.ts: repeated read warnings, anatomy lookups
  - pre-write.ts: cerebrum check, buglog lookup
  - post-read.ts: token estimation
  - post-write.ts: anatomy update, memory append, bug detection
  - stop.ts: session summary, ledger update
  - index.ts: main plugin entry point

- Map OpenCode hooks to OpenWolf infrastructure
- Add opencode-md-snippet.md template
- Update shared.ts with projectDir param + wolfDirExists()
- Exclude plugin directory from tsconfig build

Refactors monolithic 1000-line file into 10 focused modules.

Closes #6

Author: alfasin

src/cli/index.ts

@@ -31,6 +31,7 @@ export function createProgram(): Command {
   program
     .command("init")
     .description("Initialize .wolf/ in current project")
+    .option("--opencode", "Register OpenCode plugin instead of Claude Code hooks")
     .action(initCommand);
 
   program

src/cli/init.ts

@@ -118,7 +118,11 @@ const HOOK_SETTINGS = {
   },
 };
 
-export async function initCommand(): Promise<void> {
+export interface InitOptions {
+  opencode?: boolean;
+}
+
+export async function initCommand(opts: InitOptions = {}): Promise<void> {
   // Check Node.js version
   const nodeVersion = parseInt(process.version.slice(1), 10);
   if (nodeVersion < 20) {
@@ -182,35 +186,40 @@ export async function initCommand(): Promise<void> {
   // --- Hook scripts: always update (bug fixes, new features) ---
   copyHookScripts(wolfDir);
 
-  // --- Claude settings: replace OpenWolf hooks (upgrade old paths) ---
-  const claudeDir = path.join(projectRoot, ".claude");
-  ensureDir(claudeDir);
-
-  const settingsPath = path.join(claudeDir, "settings.json");
-  if (fs.existsSync(settingsPath)) {
-    const existing = readJSON<Record<string, unknown>>(settingsPath, {});
-    const merged = replaceOpenWolfHooks(existing, HOOK_SETTINGS);
-    writeJSON(settingsPath, merged);
+  if (opts.opencode) {
+    // --- OpenCode plugin ---
+    initOpenCode(projectRoot, actualTemplatesDir);
   } else {
-    writeJSON(settingsPath, HOOK_SETTINGS);
-  }
+    // --- Claude settings: replace OpenWolf hooks (upgrade old paths) ---
+    const claudeDir = path.join(projectRoot, ".claude");
+    ensureDir(claudeDir);
+
+    const settingsPath = path.join(claudeDir, "settings.json");
+    if (fs.existsSync(settingsPath)) {
+      const existing = readJSON<Record<string, unknown>>(settingsPath, {});
+      const merged = replaceOpenWolfHooks(existing, HOOK_SETTINGS);
+      writeJSON(settingsPath, merged);
+    } else {
+      writeJSON(settingsPath, HOOK_SETTINGS);
+    }
 
-  // --- Claude rules: always update ---
-  const rulesDir = path.join(claudeDir, "rules");
-  ensureDir(rulesDir);
-  const rulesContent = readTemplateContent("claude-rules-openwolf.md", actualTemplatesDir);
-  writeText(path.join(rulesDir, "openwolf.md"), rulesContent);
-
-  // --- CLAUDE.md: add snippet if missing ---
-  const claudeMdPath = path.join(projectRoot, "CLAUDE.md");
-  const snippetContent = readTemplateContent("claude-md-snippet.md", actualTemplatesDir);
-  if (fs.existsSync(claudeMdPath)) {
-    const existing = readText(claudeMdPath);
-    if (!existing.includes("OpenWolf")) {
-      writeText(claudeMdPath, snippetContent + "\n\n" + existing);
+    // --- Claude rules: always update ---
+    const rulesDir = path.join(claudeDir, "rules");
+    ensureDir(rulesDir);
+    const rulesContent = readTemplateContent("claude-rules-openwolf.md", actualTemplatesDir);
+    writeText(path.join(rulesDir, "openwolf.md"), rulesContent);
+
+    // --- CLAUDE.md: add snippet if missing ---
+    const claudeMdPath = path.join(projectRoot, "CLAUDE.md");
+    const snippetContent = readTemplateContent("claude-md-snippet.md", actualTemplatesDir);
+    if (fs.existsSync(claudeMdPath)) {
+      const existing = readText(claudeMdPath);
+      if (!existing.includes("OpenWolf")) {
+        writeText(claudeMdPath, snippetContent + "\n\n" + existing);
+      }
+    } else {
+      writeText(claudeMdPath, snippetContent);
     }
-  } else {
-    writeText(claudeMdPath, snippetContent);
   }
 
   // --- Anatomy scan: only on fresh init ---
@@ -277,14 +286,23 @@ export async function initCommand(): Promise<void> {
   } else {
     console.log(`  ✓ OpenWolf v${version} initialized`);
     console.log(`  ✓ .wolf/ created with ${createdCount} files`);
-    console.log(`  ✓ Claude Code hooks registered (6 hooks)`);
-    console.log(`  ✓ CLAUDE.md updated`);
-    console.log(`  ✓ .claude/rules/openwolf.md created`);
+    if (opts.opencode) {
+      console.log(`  ✓ OpenCode plugin registered (.opencode/plugin/openwolf.ts)`);
+      console.log(`  ✓ opencode.md updated`);
+    } else {
+      console.log(`  ✓ Claude Code hooks registered (6 hooks)`);
+      console.log(`  ✓ CLAUDE.md updated`);
+      console.log(`  ✓ .claude/rules/openwolf.md created`);
+    }
     console.log(`  ✓ Anatomy scan: ${fileCount} files indexed`);
   }
   console.log(`  ✓ Daemon: ${daemonStatus}`);
   console.log("");
-  console.log("  You're ready. Just use 'claude' as normal — OpenWolf is watching.");
+  if (opts.opencode) {
+    console.log("  You're ready. Just use 'opencode' as normal — OpenWolf is watching.");
+  } else {
+    console.log("  You're ready. Just use 'claude' as normal — OpenWolf is watching.");
+  }
   console.log("");
 }
 
@@ -324,6 +342,7 @@ function readTemplateContent(filename: string, templatesDir: string): string {
 function getEmbeddedTemplate(filename: string): string {
   const templates: Record<string, string> = {
     "claude-md-snippet.md": `# OpenWolf\n\n@.wolf/OPENWOLF.md\n\nThis project uses OpenWolf for context management. Read and follow .wolf/OPENWOLF.md every session. Check .wolf/cerebrum.md before generating code. Check .wolf/anatomy.md before reading files.`,
+    "opencode-md-snippet.md": `# OpenWolf\n\n@.wolf/OPENWOLF.md\n\nThis project uses OpenWolf for context management. Read and follow .wolf/OPENWOLF.md every session. Check .wolf/cerebrum.md before generating code. Check .wolf/anatomy.md before reading files.`,
     "claude-rules-openwolf.md": `---\ndescription: OpenWolf protocol enforcement — active on all files\nglobs: **/*\n---\n\n- Check .wolf/anatomy.md before reading any project file\n- Check .wolf/cerebrum.md Do-Not-Repeat list before generating code\n- After writing or editing files, update .wolf/anatomy.md and append to .wolf/memory.md\n- After receiving a user correction, update .wolf/cerebrum.md immediately (Preferences, Learnings, or Do-Not-Repeat)\n- LEARN from every interaction: if you discover a convention, user preference, or project pattern, add it to .wolf/cerebrum.md. Low threshold — when in doubt, log it.\n- BEFORE fixing any bug or error: read .wolf/buglog.json for known fixes\n- AFTER fixing any bug, error, failed test, failed build, or user-reported problem: ALWAYS log to .wolf/buglog.json with error_message, root_cause, fix, and tags\n- If you edit a file more than twice in a session, that likely indicates a bug — log it to .wolf/buglog.json\n- When the user asks to check/evaluate UI design: run \`openwolf designqc\` to capture screenshots, then read them from .wolf/designqc-captures/\n- When the user asks to change/pick/migrate UI framework: read .wolf/reframe-frameworks.md, ask decision questions, recommend a framework, then execute with the framework's prompt`,
   };
   return templates[filename] ?? "";
@@ -467,6 +486,74 @@ function copyHookScripts(wolfDir: string): void {
   fs.writeFileSync(hooksPkgPath, JSON.stringify({ type: "module" }, null, 2) + "\n", "utf-8");
 }
 
+/**
+ * Initialize OpenCode plugin for OpenWolf.
+ * Creates .opencode/plugin/openwolf.ts and injects snippet into opencode.md.
+ */
+function initOpenCode(projectRoot: string, templatesDir: string): void {
+  // Create .opencode/plugin/ directory
+  const pluginDir = path.join(projectRoot, ".opencode", "plugin");
+  ensureDir(pluginDir);
+
+  // Copy the plugin template directory
+  const pluginSrcDir = path.join(templatesDir, "opencode-plugin");
+  const pluginDestDir = path.join(pluginDir, "openwolf");
+
+  if (fs.existsSync(pluginSrcDir)) {
+    copyPluginDirectory(pluginSrcDir, pluginDestDir);
+  } else {
+    // Fallback: write embedded version
+    const pluginDest = path.join(pluginDir, "openwolf.ts");
+    fs.writeFileSync(pluginDest, getEmbeddedOpenCodePlugin(), "utf-8");
+  }
+
+  // Inject snippet into opencode.md (OpenCode's equivalent of CLAUDE.md)
+  const opencodeMdPath = path.join(projectRoot, "opencode.md");
+  const snippetContent = readTemplateContent("opencode-md-snippet.md", templatesDir);
+  if (fs.existsSync(opencodeMdPath)) {
+    const existing = readText(opencodeMdPath);
+    if (!existing.includes("OpenWolf")) {
+      writeText(opencodeMdPath, snippetContent + "\n\n" + existing);
+    }
+  } else {
+    writeText(opencodeMdPath, snippetContent);
+  }
+}
+
+function copyPluginDirectory(srcDir: string, destDir: string): void {
+  ensureDir(destDir);
+  const files = fs.readdirSync(srcDir);
+  for (const file of files) {
+    const srcPath = path.join(srcDir, file);
+    const destPath = path.join(destDir, file);
+    if (fs.statSync(srcPath).isDirectory()) {
+      copyPluginDirectory(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function getEmbeddedOpenCodePlugin(): string {
+  return `import type { Plugin } from "@opencode-ai/plugin"
+// OpenWolf plugin — auto-generated by openwolf init
+// For the full implementation, see the openwolf source repository.
+export const OpenWolf: Plugin = async ({ directory }) => {
+  return {
+    event: async ({ event }) => {
+      // Session lifecycle handled by .wolf/ infrastructure
+    },
+    "tool.execute.before": async (_input, _output) => {},
+    "tool.execute.after": async (_input, _output) => {},
+    stop: async (_input) => {},
+    "experimental.chat.system.transform": async (_input, output) => {
+      output.system.push("This project uses OpenWolf. Read .wolf/OPENWOLF.md for protocol instructions.")
+    },
+  }
+}
+`;
+}
+
 /**
  * Replace all OpenWolf hook entries in settings.json with the current version.
  * Removes old-style relative-path hooks and inserts the new $CLAUDE_PROJECT_DIR hooks.

src/hooks/shared.ts

@@ -2,10 +2,10 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as crypto from "node:crypto";
 
-export function getWolfDir(): string {
+export function getWolfDir(projectDir?: string): string {
   // Prefer CLAUDE_PROJECT_DIR so hooks work even if CWD changes during a session
-  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-  return path.join(projectDir, ".wolf");
+  const dir = projectDir || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  return path.join(dir, ".wolf");
 }
 
 /**
@@ -19,6 +19,14 @@ export function ensureWolfDir(): void {
   }
 }
 
+/**
+ * Check if .wolf/ directory exists without exiting.
+ * Used by the OpenCode plugin to skip processing in non-OpenWolf projects.
+ */
+export function wolfDirExists(): boolean {
+  return fs.existsSync(getWolfDir());
+}
+
 export function readJSON<T = unknown>(filePath: string, fallback: T): T {
   try {
     return JSON.parse(fs.readFileSync(filePath, "utf-8")) as T;

src/templates/opencode-md-snippet.md

@@ -0,0 +1,5 @@
+# OpenWolf
+
+@.wolf/OPENWOLF.md
+
+This project uses OpenWolf for context management. Read and follow .wolf/OPENWOLF.md every session. Check .wolf/cerebrum.md before generating code. Check .wolf/anatomy.md before reading files.

src/templates/opencode-plugin/anatomy.ts

@@ -0,0 +1,96 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import type { AnatomyEntry } from "./types.js"
+
+export function parseAnatomy(content: string): Map<string, AnatomyEntry[]> {
+  const sections = new Map<string, AnatomyEntry[]>()
+  let currentSection = ""
+  for (const line of content.split("\n")) {
+    const sm = line.match(/^## (.+)/)
+    if (sm) {
+      currentSection = sm[1].trim()
+      if (!sections.has(currentSection)) sections.set(currentSection, [])
+      continue
+    }
+    if (!currentSection) continue
+    const em = line.match(/^- `([^`]+)`(?:\s+—\s+(.+?))?\s*\(~(\d+)\s+tok\)$/)
+    if (em) {
+      sections.get(currentSection)!.push({
+        file: em[1],
+        description: em[2] || "",
+        tokens: parseInt(em[3], 10),
+      })
+    }
+  }
+  return sections
+}
+
+export function serializeAnatomy(
+  sections: Map<string, AnatomyEntry[]>,
+  metadata: { lastScanned: string; fileCount: number; hits: number; misses: number }
+): string {
+  const lines: string[] = [
+    "# anatomy.md",
+    "",
+    `> Auto-maintained by OpenWolf. Last scanned: ${metadata.lastScanned}`,
+    `> Files: ${metadata.fileCount} tracked | Anatomy hits: ${metadata.hits} | Misses: ${metadata.misses}`,
+    "",
+  ]
+  const keys = [...sections.keys()].sort()
+  for (const key of keys) {
+    lines.push(`## ${key}`)
+    lines.push("")
+    const entries = sections.get(key)!.sort((a, b) => a.file.localeCompare(b.file))
+    for (const e of entries) {
+      const desc = e.description ? ` — ${e.description}` : ""
+      lines.push(`- \`${e.file}\`${desc} (~${e.tokens} tok)`)
+    }
+    lines.push("")
+  }
+  return lines.join("\n")
+}
+
+export function extractDescription(filePath: string): string {
+  const MAX_DESC = 150
+  const basename = path.basename(filePath)
+  const ext = path.extname(basename).toLowerCase()
+  const known: Record<string, string> = {
+    "package.json": "Node.js package manifest",
+    "tsconfig.json": "TypeScript configuration",
+    ".gitignore": "Git ignore rules",
+    "README.md": "Project documentation",
+  }
+  if (known[basename]) return known[basename]
+
+  let content: string
+  try {
+    const fd = fs.openSync(filePath, "r")
+    const buf = Buffer.alloc(12288)
+    const n = fs.readSync(fd, buf, 0, 12288, 0)
+    fs.closeSync(fd)
+    content = buf.subarray(0, n).toString("utf-8")
+  } catch {
+    return ""
+  }
+  if (!content.trim()) return ""
+
+  const cap = (s: string) => s.length <= MAX_DESC ? s : s.slice(0, MAX_DESC - 3) + "..."
+
+  if (ext === ".md" || ext === ".mdx") {
+    const m = content.match(/^#{1,2}\s+(.+)$/m)
+    if (m) return cap(m[1].trim())
+  }
+
+  if (ext === ".ts" || ext === ".tsx" || ext === ".js" || ext === ".jsx") {
+    if (basename === "page.tsx" || basename === "page.js") return "Next.js page component"
+    if (basename === "layout.tsx" || basename === "layout.js") return "Next.js layout"
+    const exports = (content.match(/export\s+(?:async\s+)?(?:function|class|const|interface|type|enum)\s+(\w+)/g) || [])
+      .map(e => e.match(/(\w+)$/)?.[1]).filter(Boolean) as string[]
+    if (exports.length > 0 && exports.length <= 5) return `Exports ${exports.join(", ")}`
+    if (exports.length > 5) return cap(`Exports ${exports.slice(0, 4).join(", ")} + ${exports.length - 4} more`)
+  }
+
+  const declM = content.match(/(?:function|class|const|interface|type|enum)\s+(\w+)/)
+  if (declM) return `Declares ${declM[1]}`
+  return ""
+}

src/templates/opencode-plugin/fs.ts

@@ -0,0 +1,64 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import * as crypto from "node:crypto"
+
+export function getWolfDir(directory: string): string {
+  return path.join(directory, ".wolf")
+}
+
+export function wolfDirExists(directory: string): boolean {
+  return fs.existsSync(getWolfDir(directory))
+}
+
+export function readJSON<T>(filePath: string, fallback: T): T {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8")) as T
+  } catch {
+    return fallback
+  }
+}
+
+export function writeJSON(filePath: string, data: unknown): void {
+  const dir = path.dirname(filePath)
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+  const tmp = filePath + "." + crypto.randomBytes(4).toString("hex") + ".tmp"
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8")
+    fs.renameSync(tmp, filePath)
+  } catch {
+    try { fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8") } catch {}
+    try { fs.unlinkSync(tmp) } catch {}
+  }
+}
+
+export function readMarkdown(filePath: string): string {
+  try {
+    return fs.readFileSync(filePath, "utf-8")
+  } catch {
+    return ""
+  }
+}
+
+export function appendMarkdown(filePath: string, line: string): void {
+  const dir = path.dirname(filePath)
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+  fs.appendFileSync(filePath, line, "utf-8")
+}
+
+export function timeShort(): string {
+  const d = new Date()
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`
+}
+
+export function timestamp(): string {
+  return new Date().toISOString()
+}
+
+export function normalizePath(p: string): string {
+  return p.replace(/\\/g, "/")
+}
+
+export function estimateTokens(text: string, type: "code" | "prose" | "mixed" = "mixed"): number {
+  const ratio = type === "code" ? 3.5 : type === "prose" ? 4.0 : 3.75
+  return Math.ceil(text.length / ratio)
+}