@openviking/opencode-plugin 2026.9.9-1 → 2026.9.9

package/lib/shared/capture-utils.mjs

@@ -1,6 +1,4 @@
 // GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
-import { applyInputFilters, compileInputFilters } from "./input-filters.mjs";
-
 const TEXT_BLOCK_TYPES = new Set(["text", "input_text", "output_text"]);
 const TOOL_CALL_TYPES = new Set([
   "tool_call",
@@ -356,53 +354,6 @@ export function extractPartsFromPayload(payload, options = {}) {
   return parts;
 }
 
-/**
- * Prune blank text parts and run `cfg.captureFilters` over the ones that remain.
- *
- * One drop verdict is taken per turn, on the aggregate of its text parts; the
- * individual parts are then rewritten with the substitutions only, so a rule can
- * never both keep and drop the same turn. Tool call/result parts are carried
- * through untouched — filters match conversation text, not tool payloads — but a
- * turn dropped on its text takes its tool parts with it.
- */
-export function filterCaptureParts(parts, role, cfg = {}) {
-  const kept = [];
-  for (const part of parts || []) {
-    if (!part) continue;
-    if (part.type !== "text") {
-      kept.push(part);
-      continue;
-    }
-    const text = typeof part.text === "string" ? part.text.trim() : "";
-    if (!text) continue;
-    kept.push(text === part.text ? part : { ...part, text });
-  }
-
-  const blank = { parts: kept, dropped: false };
-  const compiled = compileInputFilters(cfg?.captureFilters);
-  if (!compiled.rules.length || kept.length === 0) return blank;
-
-  const textParts = kept.filter((part) => part.type === "text");
-  if (textParts.length === 0) return blank;
-
-  const verdict = applyInputFilters(textParts.map((part) => part.text).join("\n\n"), compiled.rules, {
-    role,
-  });
-  if (verdict.dropped) return { parts: [], dropped: true };
-
-  const out = [];
-  for (const part of kept) {
-    if (part.type !== "text") {
-      out.push(part);
-      continue;
-    }
-    const shaped = applyInputFilters(part.text, compiled.rules, { role, substituteOnly: true });
-    if (!shaped.text) continue;
-    out.push(shaped.text === part.text ? part : { ...part, text: shaped.text });
-  }
-  return { parts: out, dropped: out.length === 0 };
-}
-
 export function extractCaptureTurns(rolloutEntries, cfg = {}) {
   const toolNameById = collectToolNamesByIdFromEntries(rolloutEntries);
   const turns = [];
@@ -420,15 +371,10 @@ export function extractCaptureTurns(rolloutEntries, cfg = {}) {
       toolMaxChars: cfg.captureToolMaxChars,
       toolNameById,
     });
-    const shaped = filterCaptureParts(parts, role, cfg);
-    if (shaped.dropped) continue;
-    // With parts on the wire the drop decision was already taken above, so the
-    // text path only runs the filters for the `content` fallback. That also
-    // keeps `turn.text` faithful for callers that scan it for trigger words.
-    const decision = shouldCaptureText(rawText, role, cfg, { filters: shaped.parts.length === 0 });
-    if (!decision.shouldCapture && shaped.parts.length === 0) continue;
+    const decision = shouldCaptureText(rawText, role, cfg);
+    if (!decision.shouldCapture && parts.length === 0) continue;
     const text = decision.shouldCapture ? decision.text : "";
-    turns.push({ role, text, parts: shaped.parts });
+    turns.push({ role, text, parts });
   }
   return turns;
 }
@@ -540,21 +486,12 @@ function isPunctuationOnly(text) {
   return !/[a-z0-9\u3400-\u9fff]/i.test(text);
 }
 
-export function shouldCaptureText(text, role, cfg = {}, { filters = true } = {}) {
+export function shouldCaptureText(text, role, cfg = {}) {
   const maxLength = cfg.captureMaxLength || 24000;
   const sanitized = sanitizeCapturedText(text);
   if (!sanitized) return { shouldCapture: false, reason: "empty", text: "" };
 
-  let capped = truncateCaptureText(sanitized, maxLength);
-  if (filters) {
-    const compiled = compileInputFilters(cfg?.captureFilters);
-    if (compiled.rules.length) {
-      const verdict = applyInputFilters(capped, compiled.rules, { role });
-      if (verdict.dropped) return { shouldCapture: false, reason: "filtered", text: "" };
-      capped = verdict.text;
-      if (!capped) return { shouldCapture: false, reason: "empty", text: "" };
-    }
-  }
+  const capped = truncateCaptureText(sanitized, maxLength);
   const compact = oneLine(capped);
   const isToolSummary = /^\[tool-(?:call|result)\b/i.test(compact);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/opencode-plugin",
-  "version": "2026.9.9-1",
+  "version": "2026.9.9",
   "author": "@openviking",
   "description": "Unified OpenCode plugin for OpenViking repository retrieval and long-term memory",
   "type": "module",
@@ -44,5 +44,5 @@
     "code-search"
   ],
   "license": "Apache-2.0",
-  "openvikingSourceCommit": "708dba60bd2484a9ecb69da27383b5203d8daee2"
+  "openvikingSourceCommit": "26cb585cae254c28f17e715f906cddf9f6b45f71"
 }

package/lib/shared/input-filters.mjs

@@ -1,219 +0,0 @@
-// GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
-/**
- * Ordered, operator-configured regex filters for memory plugin input.
- *
- * Rules are sed-style strings, applied in order to a single piece of text:
- *   s/^\s*ultrathink\s+//i   substitute (add `g` to replace every match)
- *   d|^\s*[/!]|              drop the text when the pattern matches
- *   k/^\?ov\b/               keep the text only when the pattern matches
- *   user:d/^\s*\/clear\b/    apply to one role only
- *
- * A malformed rule becomes an entry in `errors` and is skipped rather than
- * throwing, so a typo in a config file cannot take a hook down.
- */
-
-const OPS = new Set(["s", "d", "k"]);
-const SCOPES = ["user", "assistant"];
-const ALLOWED_FLAGS = "imsug";
-
-export const INPUT_FILTER_KNOBS = [
-  {
-    key: "recallQueryFilters",
-    env: "OPENVIKING_RECALL_QUERY_FILTERS",
-    label: "recall query filters",
-  },
-  {
-    key: "captureFilters",
-    env: "OPENVIKING_CAPTURE_FILTERS",
-    label: "capture filters",
-  },
-];
-
-/**
- * Read one delimited field. `\` always consumes the next character, and only
- * `\<delim>` is un-escaped, so `\d` / `\b` / `\x2c` reach RegExp verbatim.
- * Returns the index of the closing delimiter, or -1 when it is missing.
- */
-function scanField(source, start, delim) {
-  let out = "";
-  let i = start;
-  while (i < source.length) {
-    const c = source[i];
-    if (c === "\\") {
-      const next = source[i + 1];
-      if (next === undefined) {
-        out += "\\";
-        i += 1;
-        continue;
-      }
-      out += next === delim ? next : "\\" + next;
-      i += 2;
-      continue;
-    }
-    if (c === delim) return { value: out, end: i };
-    out += c;
-    i += 1;
-  }
-  return { value: out, end: -1 };
-}
-
-export function parseInputFilterRule(source) {
-  if (typeof source !== "string") {
-    return { source: String(source ?? ""), error: "rule must be a string" };
-  }
-  const raw = source.trim();
-  if (!raw) return { source: raw, error: "rule is empty" };
-
-  let scope = "";
-  let rest = raw;
-  for (const candidate of SCOPES) {
-    if (rest.startsWith(`${candidate}:`)) {
-      scope = candidate;
-      rest = rest.slice(candidate.length + 1);
-      break;
-    }
-  }
-
-  const op = rest[0] || "";
-  if (!OPS.has(op)) {
-    return {
-      source: raw,
-      error: `unknown operation "${op}" — expected s (substitute), d (drop) or k (keep)`,
-    };
-  }
-  const delim = rest[1];
-  if (delim === undefined) {
-    return { source: raw, error: `missing delimiter after "${op}"` };
-  }
-  if (/[A-Za-z0-9\s\\]/.test(delim)) {
-    return {
-      source: raw,
-      error: `invalid delimiter ${JSON.stringify(delim)} — use punctuation such as / | # or :`,
-    };
-  }
-
-  const first = scanField(rest, 2, delim);
-  const pattern = first.value;
-  let replacement = null;
-  let flagsRaw = "";
-  if (op === "s") {
-    if (first.end < 0) {
-      return { source: raw, error: `missing ${JSON.stringify(delim)} after the pattern` };
-    }
-    const second = scanField(rest, first.end + 1, delim);
-    if (second.end < 0) {
-      return {
-        source: raw,
-        error: `missing ${JSON.stringify(delim)} after the replacement — write s${delim}pattern${delim}replacement${delim}`,
-      };
-    }
-    replacement = second.value;
-    flagsRaw = rest.slice(second.end + 1);
-  } else {
-    flagsRaw = first.end < 0 ? "" : rest.slice(first.end + 1);
-  }
-
-  if (!pattern) return { source: raw, error: "pattern is empty" };
-
-  const flags = new Set();
-  for (const flag of flagsRaw) {
-    if (!ALLOWED_FLAGS.includes(flag)) {
-      return { source: raw, error: `unknown flag "${flag}" — allowed flags are i, m, s, u, g` };
-    }
-    if (flags.has(flag)) return { source: raw, error: `duplicate flag "${flag}"` };
-    flags.add(flag);
-  }
-  // d/k decide with .test(), which advances lastIndex on a global regex and
-  // would then alternate between calls. `g` means nothing there, so drop it.
-  if (op !== "s") flags.delete("g");
-
-  let re;
-  try {
-    re = new RegExp(pattern, [...flags].join(""));
-  } catch (err) {
-    // V8 already says "Invalid regular expression: <pattern>: <why>"; keep that
-    // detail without stuttering the prefix the doctors key off.
-    const message = err?.message || String(err);
-    return {
-      source: raw,
-      error: /^invalid regular expression/i.test(message)
-        ? `invalid${message.slice("Invalid".length)}`
-        : `invalid regular expression: ${message}`,
-    };
-  }
-
-  return { op, scope, re, replacement, source: raw };
-}
-
-export function compileInputFilters(rules) {
-  const compiled = [];
-  const errors = [];
-  const list = Array.isArray(rules) ? rules : [];
-  list.forEach((entry, index) => {
-    if (typeof entry !== "string") {
-      errors.push({ index, source: String(entry ?? ""), message: "rule must be a string" });
-      return;
-    }
-    if (!entry.trim()) return;
-    const parsed = parseInputFilterRule(entry);
-    if (parsed.error) errors.push({ index, source: parsed.source, message: parsed.error });
-    else compiled.push({ ...parsed, index });
-  });
-  return { rules: compiled, errors };
-}
-
-/**
- * Run compiled rules over `text`.
- *
- * `substituteOnly` skips the d/k operations, so a caller that already took one
- * drop decision for a turn can rewrite its individual pieces without taking a
- * second, possibly contradictory one.
- */
-export function applyInputFilters(text, compiled, { role = "", substituteOnly = false } = {}) {
-  const original = typeof text === "string" ? text : String(text ?? "");
-  let current = original;
-  for (const rule of Array.isArray(compiled) ? compiled : []) {
-    if (rule.scope && rule.scope !== role) continue;
-    if (rule.op === "s") {
-      current = current.replace(rule.re, rule.replacement);
-      continue;
-    }
-    if (substituteOnly) continue;
-    const matched = rule.re.test(current);
-    if ((rule.op === "d" && matched) || (rule.op === "k" && !matched)) {
-      return { text: "", changed: false, dropped: true, ruleIndex: rule.index, op: rule.op };
-    }
-  }
-  const finalText = current.trim();
-  return {
-    text: finalText,
-    changed: finalText !== original,
-    dropped: false,
-    ruleIndex: -1,
-    op: "",
-  };
-}
-
-/** Doctor-facing summary of both filter knobs on a resolved plugin config. */
-export function describeInputFilters(cfg = {}) {
-  return INPUT_FILTER_KNOBS.map(({ key, env, label }) => {
-    const configured = Array.isArray(cfg?.[key]) ? cfg[key] : [];
-    const compiled = compileInputFilters(configured);
-    const ops = { s: 0, d: 0, k: 0 };
-    for (const rule of compiled.rules) ops[rule.op] += 1;
-    const bits = [];
-    if (ops.s) bits.push(`${ops.s} substitute`);
-    if (ops.d) bits.push(`${ops.d} drop`);
-    if (ops.k) bits.push(`${ops.k} keep-only`);
-    const active = compiled.rules.length;
-    return {
-      key,
-      env,
-      label,
-      total: configured.length,
-      active,
-      summary: `${active} rule${active === 1 ? "" : "s"}${bits.length ? ` (${bits.join(", ")})` : ""}`,
-      errors: compiled.errors,
-    };
-  });
-}