opencode-irf 0.0.5 → 0.0.6

package/dist/irf.js

@@ -1,632 +1,131 @@
-// 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;
+import { tool } from '@opencode-ai/plugin';
+import { discover, readFilePaths } from './src/discover';
+import { processFile } from './src/process';
+import { isFormatMode } from './src/prompt';
+import { detectModel, promptWithRetry } from './src/session';
+import { buildTable } from './src/utils/compare';
+import { safeAsync } from './src/utils/safe';
+// resolve instruction files from explicit paths or opencode.json discovery
+const resolveFiles = 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 };
     }
-    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 await discover(directory);
+};
+const ERROR_LABELS = {
+    readError: 'Read failed',
+    parseError: 'Parse failed',
+    formatError: 'Format failed',
+    writeError: 'Write failed',
+};
+// format a file result into a markdown status line
+const formatFileResult = (result) => {
+    if (result.status === 'success') {
+        return '**' + result.path + '**: ' + result.rulesCount + ' rules written';
     }
-    return {
-      data: validation.data,
-      error: null
-    };
-  }
-  return {
-    data: null,
-    error: "Failed after " + MAX_RETRIES + " attempts. Last error: " + lastError
-  };
+    return '**' + result.path + '**: ' + ERROR_LABELS[result.status] + ' - ' + result.error;
 };
-
-// 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" };
+// append comparison table section to output lines
+const appendComparisonTable = (lines, comparisons) => {
+    if (comparisons.length === 0) {
+        return;
     }
-    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")
+    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.');
+};
+// deno-lint-ignore require-await
+const 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) {
+                    // validate mode argument
+                    const mode = isFormatMode(args.mode) ? args.mode : 'balanced';
+                    try {
+                        // resolve files: explicit paths or discovery
+                        const resolved = await resolveFiles(directory, args.files);
+                        if (resolved.error !== null) {
+                            return resolved.error;
+                        }
+                        const files = resolved.data;
+                        // detect model from current session
+                        const model = await detectModel(client, context.sessionID);
+                        if (!model) {
+                            return 'Could not detect current model. Send a message first, then call irf-rewrite.';
+                        }
+                        // create a session for internal LLM calls
+                        const sessionResult = await client.session.create({
+                            body: {
+                                title: 'IRF Parse',
+                            },
+                        });
+                        if (!sessionResult.data) {
+                            return 'Failed to create internal session';
+                        }
+                        const sessionId = sessionResult.data.id;
+                        // close over session details so processFile only needs a prompt callback
+                        const prompt = (text, schema) => promptWithRetry({
+                            client,
+                            sessionId,
+                            initialPrompt: text,
+                            schema,
+                            model,
+                        });
+                        // process files sequentially; parallel prompting through a shared
+                        // session may cause ordering issues depending on SDK behavior
+                        const results = [];
+                        const comparisons = [];
+                        for (const file of files) {
+                            // bail if the tool call was cancelled
+                            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));
+                        }
+                        // clean up the internal session
+                        await safeAsync(() => client.session.delete({
+                            path: { id: sessionId },
+                        }));
+                        // build comparison table
+                        appendComparisonTable(results, comparisons);
+                        return results.join('\n');
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        return 'irf-rewrite error: ' + msg;
+                    }
+                },
+            }),
         },
-        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
+    };
 };
+export default plugin;
+//# sourceMappingURL=irf.js.map