opencode-irf 0.0.2 → 0.0.4

package/dist/irf.js

@@ -0,0 +1,632 @@
+// irf.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
+  };
+};
+
+// irf.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 plugin = 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;
+          }
+        }
+      })
+    }
+  };
+};
+var irf_default = plugin;
+export {
+  irf_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-irf",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "OpenCode plugin that converts unstructured instructions into structured rules using speech act theory and deontic logic.",
   "keywords": [
     "opencode",
@@ -25,19 +25,19 @@
   "type": "module",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": "./dist/irf.js",
+      "types": "./dist/irf.d.ts"
     }
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/irf.js",
+  "types": "./dist/irf.d.ts",
   "files": [
     "dist/",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "build": "npm run clean && tsc",
+    "build": "npm run clean && bun build irf.ts --outfile dist/irf.js --target node --external @opencode-ai/plugin --external zod",
     "clean": "rm -rf dist",
     "prepublishOnly": "npm run build"
   },

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-import type { Plugin } from '@opencode-ai/plugin';
-declare const plugin: Plugin;
-export default plugin;
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAsDjD,QAAA,MAAM,MAAM,EAAE,MAkGb,CAAA;AAED,eAAe,MAAM,CAAA"}