opencode-irf 0.0.1

package/README.md

@@ -0,0 +1,139 @@
+# Instruction Rule Formatter (IRF)
+
+An OpenCode plugin that converts unstructured instruction text into structured, consistent rules using speech act theory and deontic logic.
+
+## Quick Start
+
+Once installed, just tell OpenCode what you want:
+
+```
+Use IRF to rewrite my instruction files
+Rewrite instructions.md with IRF in verbose mode
+Use IRF to reformat docs/rules.md, concise
+```
+
+## Overview
+
+IRF takes raw instruction files and processes them through a two-step AI pipeline:
+
+1. **Parse** - Converts raw text into structured rule components (strength, action, target, context, reason)
+2. **Format** - Converts structured rules into one of three output modes: verbose, balanced, or concise
+
+### Example
+
+**Input:**
+```
+Always use return await when returning promises from async functions. This provides
+better stack traces and error handling. Arrow functions are the standard function
+syntax. Do not use function declarations or function expressions because arrow
+functions provide lexical this binding and a more compact syntax.
+```
+
+**verbose** - Full Rule/Reason pairs for every rule.
+```
+Rule: Always use return await when returning promises from async functions.
+Reason: Provides better stack traces and error handling.
+
+Rule: Use arrow functions as the standard function syntax.
+Reason: Arrow functions provide lexical this binding and a more compact syntax.
+
+Rule: Never use function declarations or function expressions.
+Reason: Arrow functions are the standard syntax for the project.
+```
+
+**balanced** (default) - The LLM decides which rules need reasons.
+```
+Rule: Always use return await when returning promises from async functions.
+Reason: Provides better stack traces and error handling.
+
+Rule: Use arrow functions as the standard function syntax.
+
+Rule: Never use function declarations or function expressions.
+Reason: Arrow functions provide lexical this binding and a more compact syntax.
+```
+
+**concise** - Bullet list of directives only, no reasons.
+```
+- Always use return await when returning promises from async functions.
+- Use arrow functions as the standard function syntax.
+- Never use function declarations or function expressions.
+```
+
+## Installation
+
+Add IRF as a global OpenCode plugin:
+
+```ts
+// ~/.config/opencode/plugins/irf.ts
+export { IRFPlugin } from '/path/to/irf/src/index.ts'
+```
+
+## Usage
+
+The `irf-rewrite` tool reads the `instructions` array from your project's `opencode.json` and processes each matched file:
+
+```json
+{
+  "instructions": ["docs/*.md", "rules/*.md"]
+}
+```
+
+```
+irf-rewrite                                    # discover from opencode.json, balanced mode
+irf-rewrite --mode concise                     # discover, concise output
+irf-rewrite --files fixtures/testing.md        # single file, balanced mode
+irf-rewrite --files a.md,b.md --mode verbose   # multiple files, verbose output
+```
+
+## Theoretical Foundation
+
+IRF is grounded in [speech act theory](https://en.wikipedia.org/wiki/Speech_act) and [deontic logic](https://en.wikipedia.org/wiki/Deontic_logic).
+
+Instructions contain performative utterances that create obligations, permissions, and prohibitions. IRF identifies the illocutionary force of each instruction by extracting action verbs, target objects, contextual conditions, and justifications.
+
+Rules are categorized using deontic strength:
+
+- **Obligatory** - Required actions that create strong obligations
+- **Forbidden** - Prohibited actions with clear boundaries
+- **Permissible** - Allowed actions within acceptable bounds
+- **Optional** - Discretionary choices left to the actor
+- **Supererogatory** - Actions that exceed normal expectations
+- **Indifferent** - Actions with no normative preference
+- **Omissible** - Actions that can be reasonably omitted
+
+### Rule Schema
+
+```ts
+type ParsedRule = {
+  strength: 'obligatory' | 'forbidden' | 'permissible' | 'optional' | 'supererogatory' | 'indifferent' | 'omissible'
+  action: string
+  target: string
+  context?: string
+  reason: string
+}
+```
+
+### Parsed Example
+
+```
+Always use return await when returning promises from async functions.
+This provides better stack traces and error handling.
+```
+
+```json
+{
+  "strength": "obligatory",
+  "action": "use",
+  "target": "return await",
+  "context": "when returning promises from async functions",
+  "reason": "better stack traces and error handling"
+}
+```
+
+## Disclaimer
+
+I'm not an NLP expert. I stumbled onto speech act theory and deontic logic while researching NLP and thought it could be a good fit for structuring instructions. I was annoyed trying to write consistent rules, thinking about phrasing and grammar, so I thought there might be a better way to approach this systematically. The implementation may not perfectly align with academic definitions, but the goal is practical utility.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,631 @@
+// src/index.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/discover.ts
+import { glob, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+// src/utils/safe.ts
+var safe = (fn) => {
+  try {
+    const data = fn();
+    return {
+      data,
+      error: null
+    };
+  } catch (error) {
+    return {
+      data: null,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+};
+var safeAsync = async (fn) => {
+  try {
+    const data = await fn();
+    return {
+      data,
+      error: null
+    };
+  } catch (error) {
+    return {
+      data: null,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+};
+
+// src/discover.ts
+var readConfig = async (directory) => {
+  const configPath = join(directory, "opencode.json");
+  const { data, error } = await safeAsync(() => readFile(configPath, "utf-8"));
+  if (error) {
+    return {
+      data: null,
+      error: "Could not read " + configPath + ": " + error.message
+    };
+  }
+  const { data: parsed, error: parseError } = safe(() => JSON.parse(data));
+  if (parseError) {
+    return {
+      data: null,
+      error: "Invalid JSON in " + configPath + ": " + parseError.message
+    };
+  }
+  const instructions = parsed.instructions;
+  if (!instructions || !Array.isArray(instructions) || instructions.length === 0) {
+    return {
+      data: null,
+      error: 'No "instructions" array found in ' + configPath
+    };
+  }
+  const patterns = instructions.filter((entry) => typeof entry === "string");
+  if (patterns.length === 0) {
+    return {
+      data: null,
+      error: 'No valid string patterns in "instructions" in ' + configPath
+    };
+  }
+  return {
+    data: patterns,
+    error: null
+  };
+};
+var resolveFiles = async (directory, patterns) => {
+  const seen = new Set;
+  const files = [];
+  for (const pattern of patterns) {
+    for await (const path of glob(pattern, { cwd: directory })) {
+      const full = join(directory, path);
+      if (!seen.has(full)) {
+        seen.add(full);
+        files.push(full);
+      }
+    }
+  }
+  return files;
+};
+var readFiles = async (files) => {
+  const results = [];
+  for (const file of files) {
+    const { data, error } = await safeAsync(() => readFile(file, "utf-8"));
+    if (error) {
+      results.push({ path: file, content: "", error: error.message });
+      continue;
+    }
+    results.push({ path: file, content: data });
+  }
+  return results;
+};
+var readFilePaths = async (directory, paths) => {
+  const resolved = paths.map((p) => resolve(directory, p));
+  return await readFiles(resolved);
+};
+var discover = async (directory) => {
+  const config = await readConfig(directory);
+  if (config.error !== null) {
+    return {
+      data: null,
+      error: config.error
+    };
+  }
+  const patterns = config.data;
+  const files = await resolveFiles(directory, patterns);
+  if (files.length === 0) {
+    return {
+      data: null,
+      error: "No instruction files found matching patterns: " + patterns.join(", ")
+    };
+  }
+  const results = await readFiles(files);
+  return {
+    data: results,
+    error: null
+  };
+};
+
+// src/process.ts
+import { writeFile } from "node:fs/promises";
+import { basename } from "node:path";
+
+// src/schema.ts
+import { z } from "zod";
+var StrengthSchema = z.enum([
+  "obligatory",
+  "permissible",
+  "forbidden",
+  "optional",
+  "supererogatory",
+  "indifferent",
+  "omissible"
+]).describe("Deontic modality expressing enforcement strength");
+var ActionSchema = z.string().describe("Imperative verb describing the action to take");
+var TargetSchema = z.string().describe("Object or subject the action applies to");
+var ContextSchema = z.string().describe("Condition, scope, or circumstance when the rule applies");
+var ReasonSchema = z.string().describe("Justification for why the rule exists");
+var ParsedRuleSchema = z.object({
+  strength: StrengthSchema,
+  action: ActionSchema,
+  target: TargetSchema,
+  context: ContextSchema.optional(),
+  reason: ReasonSchema
+}).describe("Single instruction decomposed into deontic components");
+var RuleSchema = z.string().describe("Human-readable rule derived from parsed components");
+var ParsedSchema = z.array(ParsedRuleSchema).describe("Array of parsed rules");
+var ParseResponseSchema = z.object({
+  rules: ParsedSchema
+});
+var FormatResponseSchema = z.object({
+  rules: z.array(RuleSchema)
+});
+var parseSchemaExample = JSON.stringify({
+  rules: [{
+    strength: StrengthSchema.options.join("/"),
+    action: ActionSchema.description || "verb",
+    target: TargetSchema.description || "object",
+    context: ContextSchema.description || "optional condition",
+    reason: ReasonSchema.description || "justification"
+  }]
+});
+
+// src/prompt.ts
+var FORMAT_MODES = ["verbose", "balanced", "concise"];
+var isFormatMode = (v) => typeof v === "string" && FORMAT_MODES.includes(v);
+var buildParsePrompt = (input) => {
+  const instructions = [
+    "You are a rule parser that converts raw instructions into structured parsed rules.",
+    "Take the provided instructions and break them down into structured components.",
+    "Each rule should have: strength, action (verb), target (object), context (optional condition/scope), and reason (justification).",
+    "Focus on extracting the core components without adding extra details.",
+    "",
+    "Return ONLY valid JSON matching this exact schema:",
+    parseSchemaExample,
+    "",
+    "Do not include any text outside the JSON object. Do not wrap it in markdown code fences."
+  ].join(`
+`);
+  return [instructions, "Instructions to parse:", input].join(`
+
+`);
+};
+var verboseInstructions = [
+  "You are a rule formatter that converts structured parsed rules into human-readable rules.",
+  "Take the provided parsed rule components and create natural language versions.",
+  "Every rule must include both a Rule line and a Reason line.",
+  "Each rule must follow this exact format:",
+  "",
+  "Rule: <clear, concise, actionable statement>",
+  "Reason: <justification from the parsed rule>",
+  "",
+  "Each human-readable rule should directly correspond to the parsed components without adding extra details.",
+  "Make the rules clear, concise, and actionable.",
+  "",
+  "Return ONLY valid JSON matching this exact schema:",
+  '{"rules": ["Rule: ...\\nReason: ...", "Rule: ...\\nReason: ..."]}',
+  "",
+  "Do not include any text outside the JSON object. Do not wrap it in markdown code fences."
+];
+var balancedInstructions = [
+  "You are a rule formatter that converts structured parsed rules into human-readable rules.",
+  "Take the provided parsed rule components and create natural language versions.",
+  "Use your judgment for each rule:",
+  "- If the rule is non-obvious or counterintuitive, include both the Rule and Reason lines.",
+  "- If the rule is self-explanatory, include only the Rule line and omit the Reason.",
+  "",
+  "Format rules that include a reason:",
+  "Rule: <clear, concise, actionable statement>",
+  "Reason: <justification from the parsed rule>",
+  "",
+  "Format rules that are self-explanatory:",
+  "Rule: <clear, concise, actionable statement>",
+  "",
+  "Each human-readable rule should directly correspond to the parsed components without adding extra details.",
+  "Make the rules clear, concise, and actionable.",
+  "",
+  "Return ONLY valid JSON matching this exact schema:",
+  '{"rules": ["Rule: ...\\nReason: ...", "Rule: ..."]}',
+  "",
+  "Do not include any text outside the JSON object. Do not wrap it in markdown code fences."
+];
+var conciseInstructions = [
+  "You are a rule formatter that converts structured parsed rules into concise directives.",
+  "Take the provided parsed rule components and create a bullet list of clear directives.",
+  "Do not include reasons or justifications. Output only the actionable statement.",
+  'Each rule must be a single line starting with "- " (dash space).',
+  "",
+  "Each directive should directly correspond to the parsed components without adding extra details.",
+  "Make the directives clear, concise, and actionable.",
+  "",
+  "Return ONLY valid JSON matching this exact schema:",
+  '{"rules": ["- ...", "- ..."]}',
+  "",
+  "Do not include any text outside the JSON object. Do not wrap it in markdown code fences."
+];
+var formatInstructions = {
+  verbose: verboseInstructions,
+  balanced: balancedInstructions,
+  concise: conciseInstructions
+};
+var buildFormatPrompt = (parsedRulesJson, mode = "balanced") => {
+  const instructions = formatInstructions[mode].join(`
+`);
+  return [instructions, "Parsed rules to convert:", parsedRulesJson].join(`
+
+`);
+};
+var buildRetryPrompt = (errorMessage) => {
+  return "Your previous response was invalid. " + errorMessage + `
+
+Return ONLY valid JSON. Do not include any text outside the JSON object.`;
+};
+
+// src/utils/compare.ts
+var compareBytes = (file, original, generated) => {
+  const originalBytes = new TextEncoder().encode(original).length;
+  const generatedBytes = new TextEncoder().encode(generated).length;
+  const difference = originalBytes - generatedBytes;
+  const percentChange = originalBytes === 0 ? 0 : difference / originalBytes * 100;
+  return {
+    file,
+    originalBytes,
+    generatedBytes,
+    difference,
+    percentChange
+  };
+};
+var formatChange = (difference, percentChange) => {
+  if (difference > 0) {
+    return "−" + percentChange.toFixed(1) + "%";
+  }
+  return "+" + Math.abs(percentChange).toFixed(1) + "%";
+};
+var formatRow = (result) => {
+  const changeStr = formatChange(result.difference, result.percentChange);
+  return result.file.padEnd(25) + result.originalBytes.toString().padStart(10) + result.generatedBytes.toString().padStart(12) + result.difference.toString().padStart(8) + changeStr.padStart(10);
+};
+var summarize = (results) => {
+  const totalOriginal = results.reduce((sum, r) => sum + r.originalBytes, 0);
+  const totalGenerated = results.reduce((sum, r) => sum + r.generatedBytes, 0);
+  const totalDifference = totalOriginal - totalGenerated;
+  const totalPercentChange = totalOriginal === 0 ? 0 : totalDifference / totalOriginal * 100;
+  return {
+    totalOriginal,
+    totalGenerated,
+    totalDifference,
+    totalPercentChange
+  };
+};
+var buildTable = (results) => {
+  if (results.length === 0) {
+    return "";
+  }
+  const lines = [];
+  const header = "File".padEnd(25) + "Original".padStart(10) + "Generated".padStart(12) + "Diff".padStart(8) + "Change".padStart(10);
+  const separator = "─".repeat(65);
+  lines.push(header);
+  lines.push(separator);
+  const sorted = [...results].sort((a, b) => Math.abs(b.difference) - Math.abs(a.difference));
+  for (const result of sorted) {
+    lines.push(formatRow(result));
+  }
+  const totals = summarize(results);
+  lines.push(separator);
+  const totalChangeStr = formatChange(totals.totalDifference, totals.totalPercentChange);
+  lines.push("TOTAL".padEnd(25) + totals.totalOriginal.toString().padStart(10) + totals.totalGenerated.toString().padStart(12) + totals.totalDifference.toString().padStart(8) + totalChangeStr.padStart(10));
+  lines.push("");
+  lines.push((totals.totalDifference > 0 ? "SAVED " : "INCREASED ") + Math.abs(totals.totalDifference) + " bytes (" + Math.abs(totals.totalPercentChange).toFixed(1) + "%)");
+  return lines.join(`
+`);
+};
+
+// src/process.ts
+var processFile = async (options) => {
+  const { file, prompt, mode = "balanced" } = options;
+  if (file.error) {
+    return {
+      status: "readError",
+      path: file.path,
+      error: file.error
+    };
+  }
+  const parseResult = await prompt(buildParsePrompt(file.content), ParseResponseSchema);
+  if (parseResult.error !== null) {
+    return {
+      status: "parseError",
+      path: file.path,
+      error: String(parseResult.error)
+    };
+  }
+  const formatResult = await prompt(buildFormatPrompt(JSON.stringify(parseResult.data), mode), FormatResponseSchema);
+  if (formatResult.error !== null) {
+    return {
+      status: "formatError",
+      path: file.path,
+      error: String(formatResult.error)
+    };
+  }
+  const formattedRules = formatResult.data.rules;
+  const joiner = mode === "concise" ? `
+` : `
+
+`;
+  const content = formattedRules.join(joiner) + `
+`;
+  const { error: writeError } = await safeAsync(() => writeFile(file.path, content, "utf-8"));
+  if (writeError) {
+    return {
+      status: "writeError",
+      path: file.path,
+      error: writeError.message
+    };
+  }
+  const comparison = compareBytes(basename(file.path), file.content, content);
+  return {
+    status: "success",
+    path: file.path,
+    rulesCount: formattedRules.length,
+    comparison
+  };
+};
+
+// src/utils/extractLlmError.ts
+var extractLlmError = (info) => {
+  if (!info.error) {
+    return null;
+  }
+  const err = info.error;
+  if (err.data && err.data.message) {
+    return err.data.message;
+  }
+  return err.name || "Unknown LLM error";
+};
+
+// src/utils/stripCodeFences.ts
+var stripCodeFences = (text) => {
+  return text.replace(/^.*```(?:json)?\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+};
+
+// src/utils/validate.ts
+var validateJson = (json, schema) => {
+  const { data: parsed, error } = safe(() => JSON.parse(json));
+  if (error) {
+    return {
+      data: null,
+      error: "parse"
+    };
+  }
+  const result = schema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      data: null,
+      error: "schema",
+      issues: result.error.issues
+    };
+  }
+  return {
+    data: result.data,
+    error: null
+  };
+};
+var formatValidationError = (result) => {
+  if (result.error === "parse") {
+    return "Invalid JSON. Return valid JSON.";
+  }
+  const issues = result.issues.map((i) => "  - " + i.path.join(".") + ": " + i.message).join(`
+`);
+  return `Schema validation failed:
+` + issues + `
+
+Fix the issues and try again.`;
+};
+
+// src/session.ts
+var MAX_RETRIES = 3;
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isPart = (v) => isRecord(v) && typeof v.type === "string";
+var isPartArray = (v) => Array.isArray(v) && v.every(isPart);
+var isMessageInfo = (v) => isRecord(v) && typeof v.role === "string";
+var isMessageEntry = (v) => isRecord(v) && isMessageInfo(v.info) && isPartArray(v.parts);
+var isMessageEntryArray = (v) => Array.isArray(v) && v.every(isMessageEntry);
+var extractText = (parts) => {
+  return parts.filter((p) => p.type === "text" && p.text).map((p) => p.text || "").join("");
+};
+var detectModel = async (client, sessionId) => {
+  const messagesResult = await client.session.messages({
+    path: { id: sessionId }
+  });
+  if (!messagesResult.data) {
+    return null;
+  }
+  const messages = messagesResult.data;
+  if (!isMessageEntryArray(messages)) {
+    return null;
+  }
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const info = messages[i].info;
+    if (info.role === "assistant" && info.providerID && info.modelID) {
+      return {
+        providerID: info.providerID,
+        modelID: info.modelID
+      };
+    }
+  }
+  return null;
+};
+var promptWithRetry = async (options) => {
+  const { client, sessionId, initialPrompt, schema, model } = options;
+  let prompt = initialPrompt;
+  let lastError = "";
+  for (let attempt = 0;attempt < MAX_RETRIES; attempt++) {
+    const response = await client.session.prompt({
+      path: { id: sessionId },
+      body: {
+        parts: [{ type: "text", text: prompt }],
+        tools: {},
+        model
+      }
+    });
+    if (!response.data) {
+      return {
+        data: null,
+        error: "No response from LLM (attempt " + (attempt + 1) + ")"
+      };
+    }
+    const info = response.data.info;
+    if (!isMessageInfo(info)) {
+      return {
+        data: null,
+        error: "Unexpected response shape: missing info (attempt " + (attempt + 1) + ")"
+      };
+    }
+    const llmError = extractLlmError(info);
+    if (llmError) {
+      return {
+        data: null,
+        error: llmError
+      };
+    }
+    const parts = response.data.parts;
+    if (!isPartArray(parts)) {
+      return {
+        data: null,
+        error: "Unexpected response shape: missing parts (attempt " + (attempt + 1) + ")"
+      };
+    }
+    const text = extractText(parts);
+    if (!text) {
+      lastError = "Empty response";
+      prompt = buildRetryPrompt("Empty response. Return valid JSON.");
+      continue;
+    }
+    const cleaned = stripCodeFences(text);
+    const validation = validateJson(cleaned, schema);
+    if (validation.error) {
+      const errorMsg = formatValidationError(validation);
+      lastError = errorMsg + " | raw: " + cleaned.slice(0, 200);
+      prompt = buildRetryPrompt(errorMsg);
+      continue;
+    }
+    return {
+      data: validation.data,
+      error: null
+    };
+  }
+  return {
+    data: null,
+    error: "Failed after " + MAX_RETRIES + " attempts. Last error: " + lastError
+  };
+};
+
+// src/index.ts
+var resolveFiles2 = async (directory, filesArg) => {
+  if (filesArg) {
+    const paths = filesArg.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+    if (paths.length === 0) {
+      return { data: null, error: "No valid file paths provided" };
+    }
+    return { data: await readFilePaths(directory, paths), error: null };
+  }
+  return await discover(directory);
+};
+var ERROR_LABELS = {
+  readError: "Read failed",
+  parseError: "Parse failed",
+  formatError: "Format failed",
+  writeError: "Write failed"
+};
+var formatFileResult = (result) => {
+  if (result.status === "success") {
+    return "**" + result.path + "**: " + result.rulesCount + " rules written";
+  }
+  return "**" + result.path + "**: " + ERROR_LABELS[result.status] + " - " + result.error;
+};
+var appendComparisonTable = (lines, comparisons) => {
+  if (comparisons.length === 0) {
+    return;
+  }
+  lines.push("");
+  lines.push("## Comparison");
+  lines.push("```");
+  lines.push(buildTable(comparisons));
+  lines.push("```");
+  lines.push("");
+  lines.push("IMPORTANT: Show the comparison table above to the user exactly as-is.");
+};
+var IRFPlugin = async ({ directory, client }) => {
+  return {
+    tool: {
+      "irf-rewrite": tool({
+        description: [
+          "Discover instruction files from opencode.json, parse them into structured rules, format them into human-readable rules, and write the formatted rules back to the original files.",
+          "Accepts an optional mode: verbose (full Rule/Reason pairs), balanced (LLM decides which rules need reasons), or concise (bullet list, no reasons).",
+          "Defaults to balanced.",
+          "Accepts an optional files parameter to process specific files instead of running discovery."
+        ].join(" "),
+        args: {
+          mode: tool.schema.string().optional().describe("Output format: verbose, balanced, or concise (default: balanced)"),
+          files: tool.schema.string().optional().describe("Comma-separated file paths to process instead of discovering from opencode.json")
+        },
+        async execute(args, context) {
+          const mode = isFormatMode(args.mode) ? args.mode : "balanced";
+          try {
+            const resolved = await resolveFiles2(directory, args.files);
+            if (resolved.error !== null) {
+              return resolved.error;
+            }
+            const files = resolved.data;
+            const model = await detectModel(client, context.sessionID);
+            if (!model) {
+              return "Could not detect current model. Send a message first, then call irf-rewrite.";
+            }
+            const sessionResult = await client.session.create({
+              body: {
+                title: "IRF Parse"
+              }
+            });
+            if (!sessionResult.data) {
+              return "Failed to create internal session";
+            }
+            const sessionId = sessionResult.data.id;
+            const prompt = (text, schema) => promptWithRetry({
+              client,
+              sessionId,
+              initialPrompt: text,
+              schema,
+              model
+            });
+            const results = [];
+            const comparisons = [];
+            for (const file of files) {
+              if (context.abort.aborted) {
+                results.push("Cancelled");
+                break;
+              }
+              const fileResult = await processFile({
+                file,
+                prompt,
+                mode
+              });
+              if (fileResult.status === "success") {
+                comparisons.push(fileResult.comparison);
+              }
+              results.push(formatFileResult(fileResult));
+            }
+            await safeAsync(() => client.session.delete({
+              path: { id: sessionId }
+            }));
+            appendComparisonTable(results, comparisons);
+            return results.join(`
+`);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return "irf-rewrite error: " + msg;
+          }
+        }
+      })
+    }
+  };
+};
+export {
+  IRFPlugin
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "opencode-irf",
+  "version": "0.0.1",
+  "description": "OpenCode plugin that converts unstructured instructions into structured rules using speech act theory and deontic logic.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node --external @opencode-ai/plugin --external zod",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "instructions",
+    "rules",
+    "formatting",
+    "speech-act-theory",
+    "deontic-logic"
+  ],
+  "author": "Dustin Whalen",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/whaaaley/irf.git"
+  },
+  "bugs": {
+    "url": "https://github.com/whaaaley/irf/issues"
+  },
+  "homepage": "https://github.com/whaaaley/irf#readme",
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0"
+  },
+  "dependencies": {
+    "zod": "^4.1.8"
+  }
+}