zevairouter 1.0.0

package/open-sse/index.js

@@ -0,0 +1,82 @@
+// Patch global fetch with proxy support (must be first)
+import "./utils/proxyFetch.js";
+
+// Config
+export { PROVIDERS } from "./config/providers.js";
+export { OAUTH_ENDPOINTS, CLAUDE_SYSTEM_PROMPT } from "./config/appConstants.js";
+export { CACHE_TTL, DEFAULT_MAX_TOKENS, COOLDOWN_MS, BACKOFF_CONFIG } from "./config/runtimeConfig.js";
+export { 
+  PROVIDER_MODELS, 
+  getProviderModels,
+  getDefaultModel, 
+  isValidModel,
+  findModelName,
+  getModelTargetFormat,
+  PROVIDER_ID_TO_ALIAS,
+  getModelsByProviderId
+} from "./config/providerModels.js";
+
+// Translator
+export { FORMATS } from "./translator/formats.js";
+export { 
+  register, 
+  translateRequest, 
+  translateResponse, 
+  needsTranslation, 
+  initState, 
+  initTranslators 
+} from "./translator/index.js";
+
+// Services
+export { 
+  detectFormat, 
+  getProviderConfig, 
+  buildProviderUrl, 
+  buildProviderHeaders, 
+  getTargetFormat 
+} from "./services/provider.js";
+
+export { parseModel, resolveModelAliasFromMap, getModelInfoCore } from "./services/model.js";
+
+export {
+  checkFallbackError,
+  isAccountUnavailable,
+  getUnavailableUntil,
+  filterAvailableAccounts
+} from "./services/accountFallback.js";
+
+export {
+  TOKEN_EXPIRY_BUFFER_MS,
+  refreshAccessToken,
+  refreshClaudeOAuthToken,
+  refreshGoogleToken,
+  refreshQwenToken,
+  refreshCodexToken,
+  refreshIflowToken,
+  refreshGitHubToken,
+  refreshCopilotToken,
+  getAccessToken,
+  refreshTokenByProvider
+} from "./services/tokenRefresh.js";
+
+export {
+  CODEX_MAX_REFRESH_AGE_MS,
+  shouldRefreshCredentials,
+  refreshProviderCredentials,
+  mergeRefreshedCredentials,
+  mergeProviderSpecificData,
+} from "./services/oauthCredentialManager.js";
+
+// Handlers
+export { handleChatCore, isTokenExpiringSoon } from "./handlers/chatCore.js";
+export { createStreamController, pipeWithDisconnect, createDisconnectAwareStream } from "./utils/streamHandler.js";
+
+// Executors
+export { getExecutor, hasSpecializedExecutor } from "./executors/index.js";
+
+// Utils
+export { errorResponse, formatProviderError } from "./utils/error.js";
+export { 
+  createSSETransformStreamWithLogger, 
+  createPassthroughStreamWithLogger 
+} from "./utils/stream.js";

package/open-sse/rtk/applyFilter.js

@@ -0,0 +1,15 @@
+// Port of apply_filter (rtk/src/cmds/system/pipe_cmd.rs) — catch_unwind equivalent
+// On panic/error: passthrough raw output + warn to stderr
+export function safeApply(fn, text) {
+  if (typeof fn !== "function") return text;
+  try {
+    const out = fn(text);
+    if (typeof out !== "string") return text;
+    return out;
+  } catch (err) {
+    // Rust: eprintln!("[rtk] warning: filter panicked — passing through raw output")
+    const name = fn.filterName || fn.name || "anonymous";
+    console.warn(`[rtk] warning: filter '${name}' panicked — passing through raw output: ${err?.message || err}`);
+    return text;
+  }
+}

package/open-sse/rtk/autodetect.js

@@ -0,0 +1,111 @@
+// Port of auto_detect_filter (rtk/src/cmds/system/pipe_cmd.rs:132-188) + JS extras
+// Order: git-diff → git-status → build-output → grep → find → tree → ls → search-list
+//        → read-numbered → dedup-log → smart-truncate → null
+import { DETECT_WINDOW, READ_NUMBERED_MIN_HIT_RATIO, SMART_TRUNCATE_MIN_LINES } from "./constants.js";
+import { gitDiff } from "./filters/gitDiff.js";
+import { gitStatus } from "./filters/gitStatus.js";
+import { buildOutput } from "./filters/buildOutput.js";
+import { grep } from "./filters/grep.js";
+import { find } from "./filters/find.js";
+import { dedupLog } from "./filters/dedupLog.js";
+import { ls } from "./filters/ls.js";
+import { tree } from "./filters/tree.js";
+import { smartTruncate } from "./filters/smartTruncate.js";
+import { readNumbered, READ_NUMBERED_LINE_RE } from "./filters/readNumbered.js";
+import { searchList, SEARCH_LIST_HEADER_RE } from "./filters/searchList.js";
+
+const RE_GIT_DIFF = /^diff --git /m;
+const RE_GIT_DIFF_HUNK = /^@@ /m;
+const RE_GIT_STATUS = /^On branch |^nothing to commit|^Changes (not |to be )|^Untracked files:/m;
+const RE_PORCELAIN = /^[ MADRCU?!][ MADRCU?!] \S/m;
+const RE_BUILD_OUTPUT = /^(npm (warn|error|ERR!)|yarn (warn|error)|\s*Compiling\s+\S+|\s*Downloading\s+\S+|added \d+ package|\[ERROR\]|BUILD (SUCCESS|FAILED)|\s*Finished\s+|Successfully (installed|built)|ERROR:)/im;
+const RE_TREE_GLYPH = /[├└]──|│  /;
+const RE_LS_ROW = /^[-dlbcps][rwx-]{9}/m;
+const RE_LS_TOTAL = /^total \d+$/m;
+
+export function autoDetectFilter(text) {
+  // Rust: floor_char_boundary to avoid UTF-8 split — JS .slice() by char is safe
+  const head = text.length > DETECT_WINDOW ? text.slice(0, DETECT_WINDOW) : text;
+
+  if (RE_GIT_DIFF.test(head) || RE_GIT_DIFF_HUNK.test(head)) return gitDiff;
+  if (RE_GIT_STATUS.test(head)) return gitStatus;
+
+  // Build output BEFORE porcelain check: prevents cargo "Compiling" misdetection as git-status
+  if (RE_BUILD_OUTPUT.test(head)) return buildOutput;
+
+  if (isMostlyPorcelain(head)) return gitStatus;
+
+  const lines = head.split("\n");
+  const nonEmpty = lines.filter(l => l.trim().length > 0);
+
+  // Rust grep rule: first 5 non-empty lines, ANY matches "file:number:content"
+  const first5 = nonEmpty.slice(0, 5);
+  if (first5.some(isGrepLine)) return grep;
+
+  // Rust find rule: ALL non-empty lines path-like (no ':'), >=3 lines
+  if (nonEmpty.length >= 3 && nonEmpty.every(isPathLike)) return find;
+
+  // Tree: contains box-drawing glyphs typical of `tree` command
+  if (RE_TREE_GLYPH.test(head)) return tree;
+
+  // ls -la: has "total N" header or >=3 rows starting with perms string
+  if (RE_LS_TOTAL.test(head) || countMatches(head, RE_LS_ROW) >= 3) return ls;
+
+  // Cursor Glob search list header
+  if (SEARCH_LIST_HEADER_RE.test(head)) return searchList;
+
+  // Line-numbered file dump ("  N|content") — fire only if many lines match
+  if (lines.length >= SMART_TRUNCATE_MIN_LINES && isLineNumbered(lines)) {
+    return readNumbered;
+  }
+
+  // Fallback: dedupLog for generic multi-line noise with duplicates
+  if (nonEmpty.length >= 5) return dedupLog;
+
+  // Last resort: big blob with no structure — smart truncate
+  if (text.split("\n").length >= SMART_TRUNCATE_MIN_LINES) return smartTruncate;
+
+  return null;
+}
+
+function isGrepLine(line) {
+  // Rust: splitn(3, ':') → parts.len()==3 && parts[1].parse::<usize>().is_ok()
+  const first = line.indexOf(":");
+  if (first === -1) return false;
+  const second = line.indexOf(":", first + 1);
+  if (second === -1) return false;
+  const lineno = line.slice(first + 1, second);
+  return /^\d+$/.test(lineno);
+}
+
+function isPathLike(line) {
+  const t = line.trim();
+  if (t.length === 0) return false;
+  if (t.includes(":")) return false;
+  return t.startsWith(".") || t.startsWith("/") || t.includes("/");
+}
+
+function isMostlyPorcelain(head) {
+  const lines = head.split("\n").filter(l => l.trim());
+  if (lines.length < 3) return false;
+  const hits = lines.filter(l => RE_PORCELAIN.test(l)).length;
+  return hits / lines.length >= 0.6;
+}
+
+function isLineNumbered(lines) {
+  let hits = 0;
+  let nonEmpty = 0;
+  const sample = lines.slice(0, 100);
+  for (const l of sample) {
+    if (l.length === 0) continue;
+    nonEmpty++;
+    if (READ_NUMBERED_LINE_RE.test(l)) hits++;
+  }
+  if (nonEmpty < 5) return false;
+  return hits / nonEmpty >= READ_NUMBERED_MIN_HIT_RATIO;
+}
+
+function countMatches(text, re) {
+  const g = new RegExp(re.source, re.flags.includes("g") ? re.flags : re.flags + "g");
+  return (text.match(g) || []).length;
+}

package/open-sse/rtk/caveman.js

@@ -0,0 +1,100 @@
+// Caveman injector: appends a caveman-style instruction into the system message
+// of the final request body, just before it is dispatched to the provider executor.
+// Dispatches by format so it works for both translated and native-passthrough flows.
+
+import { FORMATS } from "../translator/formats.js";
+import { CAVEMAN_PROMPTS } from "./cavemanPrompts.js";
+
+const SEP = "\n\n";
+
+export function injectCaveman(body, format, level) {
+  const prompt = CAVEMAN_PROMPTS[level];
+  if (!body || !prompt) return;
+
+  switch (format) {
+    case FORMATS.CLAUDE:
+      injectClaudeSystem(body, prompt);
+      return;
+    case FORMATS.GEMINI:
+    case FORMATS.GEMINI_CLI:
+    case FORMATS.VERTEX:
+    case FORMATS.ANTIGRAVITY:
+      // Antigravity wraps Gemini shape in body.request → injectGeminiSystem handles it
+      injectGeminiSystem(body, prompt);
+      return;
+    default:
+      // OpenAI and OpenAI-shaped formats (responses/codex/cursor/kiro/ollama)
+      injectMessagesSystem(body, prompt);
+  }
+}
+
+// OpenAI-shaped: messages[] (chat) or input[] (responses) or instructions (responses string)
+function injectMessagesSystem(body, prompt) {
+  // OpenAI Responses API: top-level string field
+  if (typeof body.instructions === "string") {
+    body.instructions = body.instructions
+      ? `${body.instructions}${SEP}${prompt}`
+      : prompt;
+    return;
+  }
+
+  const arr = Array.isArray(body.messages) ? body.messages
+    : Array.isArray(body.input) ? body.input
+    : null;
+  if (!arr) return;
+
+  const idx = arr.findIndex(m => m && (m.role === "system" || m.role === "developer"));
+  if (idx >= 0) {
+    appendToOpenAIMessage(arr[idx], prompt);
+  } else {
+    arr.unshift({ role: "system", content: prompt });
+  }
+}
+
+function appendToOpenAIMessage(msg, prompt) {
+  if (typeof msg.content === "string") {
+    msg.content = `${msg.content}${SEP}${prompt}`;
+  } else if (Array.isArray(msg.content)) {
+    // Responses-style array of parts {type:"input_text"|"text", text}
+    msg.content.push({ type: "input_text", text: prompt });
+  } else {
+    msg.content = prompt;
+  }
+}
+
+// Claude shape: body.system as string | array of {type:"text", text}
+// Insert before the last cache_control block to keep caveman inside the cached prefix.
+function injectClaudeSystem(body, prompt) {
+  if (typeof body.system === "string" && body.system.length > 0) {
+    body.system = `${body.system}${SEP}${prompt}`;
+    return;
+  }
+  if (Array.isArray(body.system)) {
+    const block = { type: "text", text: prompt };
+    let lastCacheIdx = -1;
+    for (let i = body.system.length - 1; i >= 0; i--) {
+      if (body.system[i]?.cache_control) { lastCacheIdx = i; break; }
+    }
+    if (lastCacheIdx >= 0) {
+      body.system.splice(lastCacheIdx, 0, block);
+    } else {
+      body.system.push(block);
+    }
+    return;
+  }
+  body.system = prompt;
+}
+
+// Gemini shape: body.system_instruction | body.systemInstruction | body.request.systemInstruction
+// Each shape: { parts: [{ text }] }
+function injectGeminiSystem(body, prompt) {
+  const target = body.request && typeof body.request === "object" ? body.request : body;
+  const useSnake = Object.prototype.hasOwnProperty.call(target, "system_instruction");
+  const key = useSnake ? "system_instruction" : "systemInstruction";
+  const sys = target[key];
+  if (sys && Array.isArray(sys.parts)) {
+    sys.parts.push({ text: prompt });
+    return;
+  }
+  target[key] = { parts: [{ text: prompt }] };
+}

package/open-sse/rtk/cavemanPrompts.js

@@ -0,0 +1,78 @@
+// Caveman intensity-level prompts injected into system message to reduce output tokens.
+// Adapted from caveman skill (https://github.com/JuliusBrussee/caveman).
+
+export const CAVEMAN_LEVELS = {
+  LITE: "lite",
+  FULL: "full",
+  ULTRA: "ultra",
+  WENYAN_LITE: "wenyan-lite",
+  WENYAN: "wenyan",
+  WENYAN_ULTRA: "wenyan-ultra",
+};
+
+const SHARED_BOUNDARIES = "Code blocks, file paths, commands, errors, URLs: keep exact. Security warnings, irreversible action confirmations, multi-step ordered sequences: write normal. Resume terse style after.";
+
+const SHARED_EXAMPLES = "Not: \"Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by...\" Yes: \"Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:\"";
+
+const SHARED_AUTO_CLARITY = "Auto-Clarity: drop caveman for security warnings, irreversible actions, multi-step sequences where fragment ambiguity risks misread, or when user repeats a question. Resume after the clear part.";
+
+const SHARED_PERSISTENCE = "ACTIVE EVERY RESPONSE. No revert after many turns. No filler drift. Still active if unsure.";
+
+export const CAVEMAN_PROMPTS = {
+  [CAVEMAN_LEVELS.LITE]: [
+    "Respond tersely. Keep grammar and full sentences but drop filler, hedging and pleasantries (just/really/basically/sure/of course/I'd be happy to).",
+    "Pattern: state the thing, the action, the reason. Then next step.",
+    SHARED_EXAMPLES,
+    SHARED_BOUNDARIES,
+    SHARED_AUTO_CLARITY,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+
+  [CAVEMAN_LEVELS.FULL]: [
+    "Respond like terse caveman. All technical substance stay exact, only fluff die.",
+    "Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries, hedging. Fragments OK. Short synonyms (big not extensive, fix not implement a solution for).",
+    "Pattern: [thing] [action] [reason]. [next step].",
+    SHARED_EXAMPLES,
+    SHARED_BOUNDARIES,
+    SHARED_AUTO_CLARITY,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+
+  [CAVEMAN_LEVELS.ULTRA]: [
+    "Respond ultra-terse. Maximum compression. Telegraphic.",
+    "Abbreviate (DB/auth/config/req/res/fn/impl), strip conjunctions, use arrows for causality (X → Y). One word when one word enough.",
+    "Pattern: [thing] → [result]. [fix].",
+    SHARED_EXAMPLES,
+    SHARED_BOUNDARIES,
+    SHARED_AUTO_CLARITY,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+
+  [CAVEMAN_LEVELS.WENYAN_LITE]: [
+    "Respond semi-classical. Drop filler/hedging but keep grammar structure, classical register.",
+    "Use classical Chinese sentence patterns where natural. Keep English for technical terms.",
+    SHARED_EXAMPLES,
+    SHARED_BOUNDARIES,
+    SHARED_AUTO_CLARITY,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+
+  [CAVEMAN_LEVELS.WENYAN]: [
+    "Respond classical Chinese (文言文). Maximum classical terseness. 80-90% character reduction.",
+    "Classical sentence patterns, verbs precede objects, subjects often omitted, classical particles (之/乃/為/其).",
+    "Keep English for code, commands, function names, API names, error strings.",
+    SHARED_EXAMPLES,
+    SHARED_BOUNDARIES,
+    SHARED_AUTO_CLARITY,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+
+  [CAVEMAN_LEVELS.WENYAN_ULTRA]: [
+    "Respond extreme classical compression (文言文 ultra). Maximum compression, ultra terse.",
+    "Same classical rules as wenyan-full but even more compressed. One classical particle per clause.",
+    SHARED_EXAMPLES,
+    SHARED_BOUNDARIES,
+    SHARED_AUTO_CLARITY,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+};

package/open-sse/rtk/constants.js

@@ -0,0 +1,55 @@
+// RTK port constants (mirror Rust defaults)
+export const RAW_CAP = 10 * 1024 * 1024;      // 10 MiB
+export const MIN_COMPRESS_SIZE = 500;          // bytes; skip tiny blobs
+export const DETECT_WINDOW = 1024;             // autodetect peeks first N chars
+export const GIT_DIFF_HUNK_MAX_LINES = 100;    // per-hunk line cap
+export const GIT_DIFF_CONTEXT_KEEP = 3;        // context lines around changes
+export const DEDUP_LINE_MAX = 2000;            // dedupLog truncation cap
+
+// Rust pipe_cmd.rs parity caps
+export const GREP_PER_FILE_MAX = 10;           // match rust: matches.iter().take(10)
+export const FIND_PER_DIR_MAX = 10;            // match rust: files.iter().take(10)
+export const FIND_TOTAL_DIR_MAX = 20;          // match rust: dirs.iter().take(20)
+
+// git status caps (rust config::limits())
+export const STATUS_MAX_FILES = 10;            // config::limits().status_max_files
+export const STATUS_MAX_UNTRACKED = 10;        // config::limits().status_max_untracked
+
+// ls compact_ls (rtk/src/cmds/system/ls.rs)
+export const LS_EXT_SUMMARY_TOP = 5;           // top-N extensions in summary
+export const LS_NOISE_DIRS = [
+  "node_modules", ".git", "target", "__pycache__",
+  ".next", "dist", "build", ".venv", "venv",
+  ".cache", ".idea", ".vscode", ".DS_Store"
+];
+
+// tree filter_tree_output cap (no rust cap, we add one to be safe)
+export const TREE_MAX_LINES = 200;
+
+// Cursor Glob "Result of search in '...' (total N files):" list
+export const SEARCH_LIST_PER_DIR_MAX = 10;
+export const SEARCH_LIST_TOTAL_DIR_MAX = 20;
+
+// Smart truncate (port of filter.rs smart_truncate fallback)
+export const SMART_TRUNCATE_HEAD = 120;        // lines kept from top
+export const SMART_TRUNCATE_TAIL = 60;         // lines kept from bottom
+export const SMART_TRUNCATE_MIN_LINES = 250;   // only kick in above this
+
+// readNumbered (files with "  N|content" lines, e.g. Cursor read_file)
+export const READ_NUMBERED_MIN_HIT_RATIO = 0.7;
+
+// Filter name strings (Rust parity + JS extras)
+export const FILTERS = {
+  GIT_DIFF: "git-diff",
+  GIT_STATUS: "git-status",
+  GIT_LOG: "git-log",
+  GREP: "grep",
+  FIND: "find",
+  LS: "ls",
+  TREE: "tree",
+  DEDUP_LOG: "dedup-log",
+  SMART_TRUNCATE: "smart-truncate",
+  READ_NUMBERED: "read-numbered",
+  SEARCH_LIST: "search-list",
+  BUILD_OUTPUT: "build-output"
+};

package/open-sse/rtk/filters/buildOutput.js

@@ -0,0 +1,127 @@
+// Compress build tool output (npm, cargo, pip, maven, gradle, etc.)
+// Keeps: errors, warnings, final summary
+// Strips: progress logs, verbose "Compiling X" lists, download logs
+
+// Cargo/rustc error continuation: " --> file:line", "  |", "N | code", "  = note: ..."
+const RE_CARGO_ERR_CONT = /^\s*(-->|\||\d+\s*\||=)/;
+const DEPRECATION_KEEP = 3;
+
+export function buildOutput(input) {
+  const lines = input.split("\n");
+  if (lines.length === 0) return input;
+
+  const errors = [];
+  const warnings = [];
+  const deprecations = [];
+  let summary = null;
+  let compilingCount = 0;
+  let downloadingCount = 0;
+  let inCargoError = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Continuation of cargo error block: keep verbatim while in block
+    if (inCargoError) {
+      if (!trimmed) { inCargoError = false; continue; }
+      if (RE_CARGO_ERR_CONT.test(line)) { errors.push(line); continue; }
+      inCargoError = false;
+    }
+
+    if (!trimmed) continue;
+
+    if (/^npm (ERR!|error)/i.test(trimmed) || /^yarn error/i.test(trimmed)) {
+      errors.push(line);
+      continue;
+    }
+
+    if (/^npm warn deprecated/i.test(trimmed)) {
+      deprecations.push(line);
+      continue;
+    }
+    if (/^npm warn/i.test(trimmed) || /^yarn warn/i.test(trimmed)) {
+      warnings.push(line);
+      continue;
+    }
+
+    if (/^error(\[|:)/i.test(trimmed) || trimmed.startsWith("error -->")) {
+      errors.push(line);
+      inCargoError = true;
+      continue;
+    }
+
+    if (/^warning(\[|:)/i.test(trimmed) || trimmed.startsWith("warning -->")) {
+      warnings.push(line);
+      inCargoError = true;
+      continue;
+    }
+
+    if (/^ERROR:/i.test(trimmed)) {
+      errors.push(line);
+      continue;
+    }
+
+    if (/^\[ERROR\]/i.test(trimmed) || /^BUILD FAILED/i.test(trimmed)) {
+      errors.push(line);
+      continue;
+    }
+
+    if (/^\[WARNING\]/i.test(trimmed)) {
+      warnings.push(line);
+      continue;
+    }
+
+    if (/^\s*Compiling\s+\S+/i.test(trimmed)) {
+      compilingCount++;
+      continue;
+    }
+    if (/^\s*Downloading\s+\S+/i.test(trimmed) || /^Fetching\s+/i.test(trimmed)) {
+      downloadingCount++;
+      continue;
+    }
+
+    if (
+      /^(added|removed|changed|audited|installed)\s+\d+\s+package/i.test(trimmed) ||
+      /^\s*Finished\s+/i.test(trimmed) ||
+      /^BUILD SUCCESS/i.test(trimmed) ||
+      /^\d+\s+(vulnerabilities|packages?|warnings?|errors?)/i.test(trimmed) ||
+      /^Successfully (installed|built)/i.test(trimmed) ||
+      /^To address .* issues/i.test(trimmed) ||
+      /^Run `npm (audit|fund)`/i.test(trimmed) ||
+      /packages are looking for funding/i.test(trimmed)
+    ) {
+      summary = summary ? `${summary}\n${line}` : line;
+      continue;
+    }
+  }
+
+  let out = "";
+
+  // Keep first N deprecations verbatim (package name + reason), count the rest
+  const keepDep = deprecations.slice(0, DEPRECATION_KEEP);
+  for (const d of keepDep) out += `${d}\n`;
+  if (deprecations.length > DEPRECATION_KEEP) {
+    out += `... +${deprecations.length - DEPRECATION_KEEP} more deprecated packages\n`;
+  }
+
+  if (compilingCount > 0) {
+    out += `Compiled ${compilingCount} packages\n`;
+  }
+  if (downloadingCount > 0) {
+    out += `Downloaded ${downloadingCount} packages\n`;
+  }
+
+  for (const e of errors) out += `${e}\n`;
+
+  const keepWarnings = warnings.slice(0, 5);
+  for (const w of keepWarnings) out += `${w}\n`;
+  if (warnings.length > 5) {
+    out += `... +${warnings.length - 5} more warnings\n`;
+  }
+
+  if (summary) out += `${summary}\n`;
+
+  return out.replace(/\n+$/, "") || input;
+}
+
+buildOutput.filterName = "build-output";

package/open-sse/rtk/filters/dedupLog.js

@@ -0,0 +1,44 @@
+// Generic fallback: collapse consecutive duplicate lines + blank-line dedupe + hard line cap
+import { DEDUP_LINE_MAX } from "../constants.js";
+
+export function dedupLog(input) {
+  const lines = input.split("\n");
+  const out = [];
+  let prev = null;
+  let runCount = 0;
+  let blankStreak = 0;
+
+  const flushRun = () => {
+    if (prev !== null && runCount > 1) {
+      out.push(`  ... (${runCount - 1} duplicate lines)`);
+    }
+  };
+
+  for (const line of lines) {
+    if (line.trim() === "") {
+      if (blankStreak < 1) out.push(line);
+      blankStreak += 1;
+      flushRun();
+      prev = null;
+      runCount = 0;
+      continue;
+    }
+    blankStreak = 0;
+    if (line === prev) {
+      runCount += 1;
+      continue;
+    }
+    flushRun();
+    out.push(line);
+    prev = line;
+    runCount = 1;
+    if (out.length >= DEDUP_LINE_MAX) {
+      out.push(`... (truncated at ${DEDUP_LINE_MAX} lines)`);
+      return out.join("\n");
+    }
+  }
+  flushRun();
+  return out.join("\n");
+}
+
+dedupLog.filterName = "dedup-log";

package/open-sse/rtk/filters/find.js

@@ -0,0 +1,49 @@
+// Port of find_wrapper (rtk/src/cmds/system/pipe_cmd.rs:89-128)
+// Group by parent dir, show basenames, cap 10/dir and 20 dirs total
+import { FIND_PER_DIR_MAX, FIND_TOTAL_DIR_MAX } from "../constants.js";
+
+export function find(input) {
+  const lines = input.split("\n").filter(l => l.trim());
+  if (lines.length === 0) return input;
+
+  const byDir = new Map();
+
+  for (const path of lines) {
+    const lastSlash = path.lastIndexOf("/");
+    let dir;
+    let basename;
+    if (lastSlash === -1) {
+      dir = ".";
+      basename = path;
+    } else {
+      // Rust: PathBuf::from(path).parent().display() + file_name().display()
+      dir = path.slice(0, lastSlash) || "/";
+      basename = path.slice(lastSlash + 1);
+    }
+    if (!byDir.has(dir)) byDir.set(dir, []);
+    byDir.get(dir).push(basename);
+  }
+
+  // Rust: dirs.sort_by_key(|(d, _)| d.clone())
+  const dirs = Array.from(byDir.keys()).sort();
+  let out = `${lines.length} files in ${dirs.length} dirs:\n\n`;
+
+  const showDirs = dirs.slice(0, FIND_TOTAL_DIR_MAX);
+  for (const dir of showDirs) {
+    const files = byDir.get(dir);
+    out += `${dir}/ (${files.length}):\n`;
+    const showFiles = files.slice(0, FIND_PER_DIR_MAX);
+    for (const f of showFiles) out += `  ${f}\n`;
+    if (files.length > FIND_PER_DIR_MAX) {
+      out += `  +${files.length - FIND_PER_DIR_MAX}\n`;
+    }
+    out += "\n";
+  }
+  if (dirs.length > FIND_TOTAL_DIR_MAX) {
+    out += `+${dirs.length - FIND_TOTAL_DIR_MAX} more dirs\n`;
+  }
+
+  return out;
+}
+
+find.filterName = "find";