swayrouter 1.0.0

package/src/rtk/filters/gitStatus.js

@@ -0,0 +1,101 @@
+import { STATUS_MAX_FILES, STATUS_MAX_UNTRACKED } from "../constants.js";
+
+export function gitStatus(input) {
+  const lines = input.split("\n");
+  if (lines.length === 0 || (lines.length === 1 && !lines[0].trim())) {
+    return "Clean working tree";
+  }
+
+  let branch = "";
+  const stagedFiles = [];
+  const modifiedFiles = [];
+  const untrackedFiles = [];
+  let staged = 0;
+  let modified = 0;
+  let untracked = 0;
+  let conflicts = 0;
+
+  for (const raw of lines) {
+    if (!raw.trim()) continue;
+
+    const longBranch = raw.match(/^On branch (\S+)/);
+    if (longBranch) { branch = longBranch[1]; continue; }
+
+    if (raw.startsWith("##")) { branch = raw.replace(/^##\s*/, ""); continue; }
+
+    if (raw.length >= 3 && /^[ MADRCU?!][ MADRCU?!] /.test(raw)) {
+      const x = raw[0];
+      const y = raw[1];
+      const file = raw.slice(3);
+
+      if (raw.slice(0, 2) === "??") {
+        untracked++;
+        untrackedFiles.push(file);
+        continue;
+      }
+
+      if ("MADRC".includes(x)) {
+        staged++;
+        stagedFiles.push(file);
+      } else if (x === "U") {
+        conflicts++;
+      }
+
+      if (y === "M" || y === "D") {
+        modified++;
+        modifiedFiles.push(file);
+      }
+      continue;
+    }
+
+    const longMatch = raw.match(/^\s*(modified|new file|deleted|renamed|both modified):\s+(.+)$/);
+    if (longMatch) {
+      const kind = longMatch[1];
+      const path = longMatch[2].trim();
+      if (kind === "both modified") { conflicts++; }
+      else if (kind === "modified" || kind === "deleted") { modified++; modifiedFiles.push(path); }
+      else if (kind === "new file" || kind === "renamed") { staged++; stagedFiles.push(path); }
+      continue;
+    }
+
+  }
+
+  let out = "";
+  if (branch) out += `* ${branch}\n`;
+
+  if (staged > 0) {
+    out += `+ Staged: ${staged} files\n`;
+    for (const f of stagedFiles.slice(0, STATUS_MAX_FILES)) out += `   ${f}\n`;
+    if (stagedFiles.length > STATUS_MAX_FILES) {
+      out += `   ... +${stagedFiles.length - STATUS_MAX_FILES} more\n`;
+    }
+  }
+
+  if (modified > 0) {
+    out += `~ Modified: ${modified} files\n`;
+    for (const f of modifiedFiles.slice(0, STATUS_MAX_FILES)) out += `   ${f}\n`;
+    if (modifiedFiles.length > STATUS_MAX_FILES) {
+      out += `   ... +${modifiedFiles.length - STATUS_MAX_FILES} more\n`;
+    }
+  }
+
+  if (untracked > 0) {
+    out += `? Untracked: ${untracked} files\n`;
+    for (const f of untrackedFiles.slice(0, STATUS_MAX_UNTRACKED)) out += `   ${f}\n`;
+    if (untrackedFiles.length > STATUS_MAX_UNTRACKED) {
+      out += `   ... +${untrackedFiles.length - STATUS_MAX_UNTRACKED} more\n`;
+    }
+  }
+
+  if (conflicts > 0) {
+    out += `conflicts: ${conflicts} files\n`;
+  }
+
+  if (staged === 0 && modified === 0 && untracked === 0 && conflicts === 0) {
+    out += "clean — nothing to commit\n";
+  }
+
+  return out.replace(/\n+$/, "");
+}
+
+gitStatus.filterName = "git-status";

package/src/rtk/filters/grep.js

@@ -0,0 +1,45 @@
+import { GREP_PER_FILE_MAX } from "../constants.js";
+
+export function grep(input) {
+  const byFile = new Map();
+  let total = 0;
+
+  for (const line of input.split("\n")) {
+
+    const first = line.indexOf(":");
+    if (first === -1) continue;
+    const second = line.indexOf(":", first + 1);
+    if (second === -1) continue;
+    const file = line.slice(0, first);
+    const lineNumStr = line.slice(first + 1, second);
+    const content = line.slice(second + 1);
+
+    if (!/^\d+$/.test(lineNumStr)) continue;
+    total++;
+    if (!byFile.has(file)) byFile.set(file, []);
+    byFile.get(file).push([lineNumStr, content]);
+  }
+
+  if (total === 0) return input;
+
+  const files = Array.from(byFile.keys()).sort();
+  let out = `${total} matches in ${files.length}F:\n\n`;
+
+  for (const file of files) {
+    const matches = byFile.get(file);
+    out += `[file] ${file} (${matches.length}):\n`;
+    const show = matches.slice(0, GREP_PER_FILE_MAX);
+    for (const [lineNum, content] of show) {
+
+      out += `  ${lineNum.padStart(4)}: ${content.trim()}\n`;
+    }
+    if (matches.length > GREP_PER_FILE_MAX) {
+      out += `  +${matches.length - GREP_PER_FILE_MAX}\n`;
+    }
+    out += "\n";
+  }
+
+  return out;
+}
+
+grep.filterName = "grep";

package/src/rtk/filters/ls.js

@@ -0,0 +1,73 @@
+import { LS_EXT_SUMMARY_TOP, LS_NOISE_DIRS } from "../constants.js";
+
+const LS_DATE_RE = /\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2}\s+(\d{4}|\d{2}:\d{2})\s+/;
+
+function humanSize(bytes) {
+  if (bytes >= 1_048_576) return `${(bytes / 1_048_576).toFixed(1)}M`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)}K`;
+  return `${bytes}B`;
+}
+
+function parseLsLine(line) {
+  const m = LS_DATE_RE.exec(line);
+  if (!m) return null;
+  const name = line.slice(m.index + m[0].length);
+  const beforeDate = line.slice(0, m.index);
+  const beforeParts = beforeDate.split(/\s+/).filter(Boolean);
+  if (beforeParts.length < 4) return null;
+
+  const perms = beforeParts[0];
+  const fileType = perms.charAt(0);
+
+  let size = 0;
+  for (let i = beforeParts.length - 1; i >= 0; i--) {
+    const n = Number(beforeParts[i]);
+    if (Number.isInteger(n) && String(n) === beforeParts[i]) { size = n; break; }
+  }
+  return { fileType, size, name };
+}
+
+export function ls(input) {
+  const dirs = [];
+  const files = [];
+  const byExt = new Map();
+
+  for (const line of input.split("\n")) {
+    if (line.startsWith("total ") || line.length === 0) continue;
+    const parsed = parseLsLine(line);
+    if (!parsed) continue;
+    if (parsed.name === "." || parsed.name === "..") continue;
+
+    if (LS_NOISE_DIRS.includes(parsed.name)) continue;
+
+    if (parsed.fileType === "d") {
+      dirs.push(parsed.name);
+    } else if (parsed.fileType === "-" || parsed.fileType === "l") {
+      const dot = parsed.name.lastIndexOf(".");
+      const ext = dot > 0 ? parsed.name.slice(dot) : "no ext";
+      byExt.set(ext, (byExt.get(ext) || 0) + 1);
+      files.push([parsed.name, humanSize(parsed.size)]);
+    }
+  }
+
+  if (dirs.length === 0 && files.length === 0) return input;
+
+  let out = "";
+  for (const d of dirs) out += `${d}/\n`;
+  for (const [name, size] of files) out += `${name}  ${size}\n`;
+
+  let summary = `\nSummary: ${files.length} files, ${dirs.length} dirs`;
+  if (byExt.size > 0) {
+    const ext = Array.from(byExt.entries()).sort((a, b) => b[1] - a[1]);
+    const parts = ext.slice(0, LS_EXT_SUMMARY_TOP).map(([e, c]) => `${c} ${e}`);
+    summary += ` (${parts.join(", ")}`;
+    if (ext.length > LS_EXT_SUMMARY_TOP) {
+      summary += `, +${ext.length - LS_EXT_SUMMARY_TOP} more`;
+    }
+    summary += ")";
+  }
+
+  return out + summary;
+}
+
+ls.filterName = "ls";

package/src/rtk/filters/readNumbered.js

@@ -0,0 +1,22 @@
+import { SMART_TRUNCATE_HEAD, SMART_TRUNCATE_TAIL, SMART_TRUNCATE_MIN_LINES } from "../constants.js";
+
+const LINE_RE = /^\s*\d+\|/;
+
+export function readNumbered(input) {
+  const lines = input.split("\n");
+  if (lines.length < SMART_TRUNCATE_MIN_LINES) return input;
+
+  const head = lines.slice(0, SMART_TRUNCATE_HEAD);
+  const tail = lines.slice(lines.length - SMART_TRUNCATE_TAIL);
+  const cut = lines.length - head.length - tail.length;
+
+  return [
+    ...head,
+    `... +${cut} lines truncated (file continues)`,
+    ...tail
+  ].join("\n");
+}
+
+readNumbered.filterName = "read-numbered";
+
+export const READ_NUMBERED_LINE_RE = LINE_RE;

package/src/rtk/filters/searchList.js

@@ -0,0 +1,49 @@
+import { SEARCH_LIST_PER_DIR_MAX, SEARCH_LIST_TOTAL_DIR_MAX } from "../constants.js";
+
+const HEADER_RE = /^Result of search in '[^']*' \(total (\d+) files?\):/;
+
+export function searchList(input) {
+  const lines = input.split("\n");
+  if (lines.length === 0) return input;
+
+  const header = lines[0] || "";
+  const rest = lines.slice(1);
+
+  const paths = [];
+  for (const raw of rest) {
+    const t = raw.trim();
+    if (!t.startsWith("- ")) continue;
+    paths.push(t.slice(2));
+  }
+  if (paths.length === 0) return input;
+
+  const byDir = new Map();
+  for (const p of paths) {
+    const slash = p.lastIndexOf("/");
+    const dir = slash === -1 ? "." : (p.slice(0, slash) || "/");
+    const name = slash === -1 ? p : p.slice(slash + 1);
+    if (!byDir.has(dir)) byDir.set(dir, []);
+    byDir.get(dir).push(name);
+  }
+
+  const dirs = Array.from(byDir.keys()).sort();
+  let out = `${header}\n${paths.length} files in ${dirs.length} dirs:\n\n`;
+
+  for (const dir of dirs.slice(0, SEARCH_LIST_TOTAL_DIR_MAX)) {
+    const names = byDir.get(dir);
+    out += `${dir}/ (${names.length}):\n`;
+    for (const n of names.slice(0, SEARCH_LIST_PER_DIR_MAX)) out += `  ${n}\n`;
+    if (names.length > SEARCH_LIST_PER_DIR_MAX) {
+      out += `  +${names.length - SEARCH_LIST_PER_DIR_MAX}\n`;
+    }
+    out += "\n";
+  }
+  if (dirs.length > SEARCH_LIST_TOTAL_DIR_MAX) {
+    out += `+${dirs.length - SEARCH_LIST_TOTAL_DIR_MAX} more dirs\n`;
+  }
+
+  return out.replace(/\n+$/, "");
+}
+
+searchList.filterName = "search-list";
+export const SEARCH_LIST_HEADER_RE = HEADER_RE;

package/src/rtk/filters/smartTruncate.js

@@ -0,0 +1,13 @@
+import { SMART_TRUNCATE_HEAD, SMART_TRUNCATE_TAIL, SMART_TRUNCATE_MIN_LINES } from "../constants.js";
+
+export function smartTruncate(input) {
+  const lines = input.split("\n");
+  if (lines.length < SMART_TRUNCATE_MIN_LINES) return input;
+
+  const head = lines.slice(0, SMART_TRUNCATE_HEAD);
+  const tail = lines.slice(lines.length - SMART_TRUNCATE_TAIL);
+  const cut = lines.length - head.length - tail.length;
+  return [...head, `... +${cut} lines truncated`, ...tail].join("\n");
+}
+
+smartTruncate.filterName = "smart-truncate";

package/src/rtk/filters/tree.js

@@ -0,0 +1,28 @@
+import { TREE_MAX_LINES } from "../constants.js";
+
+export function tree(input) {
+  const lines = input.split("\n");
+  if (lines.length === 0) return input;
+
+  const filtered = [];
+  for (const line of lines) {
+
+    if (line.includes("director") && line.includes("file")) continue;
+
+    if (line.trim() === "" && filtered.length === 0) continue;
+    filtered.push(line);
+  }
+
+  while (filtered.length > 0 && filtered[filtered.length - 1].trim() === "") {
+    filtered.pop();
+  }
+
+  if (filtered.length > TREE_MAX_LINES) {
+    const cut = filtered.length - TREE_MAX_LINES;
+    return filtered.slice(0, TREE_MAX_LINES).join("\n") + `\n... +${cut} more lines`;
+  }
+
+  return filtered.join("\n");
+}
+
+tree.filterName = "tree";

package/src/rtk/index.js

@@ -0,0 +1,143 @@
+import { RAW_CAP, MIN_COMPRESS_SIZE } from "./constants.js";
+import { autoDetectFilter } from "./autodetect.js";
+import { safeApply } from "./applyFilter.js";
+
+export function compressMessages(body, enabled) {
+  if (!enabled) return null;
+  if (!body) return null;
+
+  if (body.conversationState) {
+    return compressKiroFormat(body, enabled);
+  }
+
+  const items = Array.isArray(body.messages) ? body.messages
+    : Array.isArray(body.input) ? body.input
+    : null;
+  if (!items) return null;
+
+  const stats = { bytesBefore: 0, bytesAfter: 0, hits: [] };
+  try {
+    for (let i = 0; i < items.length; i++) {
+      const msg = items[i];
+      if (!msg) continue;
+
+      if (msg.type === "function_call_output") {
+        if (typeof msg.output === "string") {
+          msg.output = compressText(msg.output, stats, "openai-responses-string");
+        } else if (Array.isArray(msg.output)) {
+          for (let k = 0; k < msg.output.length; k++) {
+            const part = msg.output[k];
+            if (part && part.type === "input_text" && typeof part.text === "string") {
+              part.text = compressText(part.text, stats, "openai-responses-array");
+            }
+          }
+        }
+        continue;
+      }
+
+      if (msg.role === "tool" && typeof msg.content === "string") {
+        msg.content = compressText(msg.content, stats, "openai-tool");
+        continue;
+      }
+
+      if (!Array.isArray(msg.content)) continue;
+
+      if (msg.role === "tool") {
+        for (let k = 0; k < msg.content.length; k++) {
+          const part = msg.content[k];
+          if (part && part.type === "text" && typeof part.text === "string") {
+            part.text = compressText(part.text, stats, "openai-tool-array");
+          }
+        }
+        continue;
+      }
+
+      for (let j = 0; j < msg.content.length; j++) {
+        const block = msg.content[j];
+        if (!block || block.type !== "tool_result") continue;
+        if (block.is_error === true) continue;
+
+        if (typeof block.content === "string") {
+
+          block.content = compressText(block.content, stats, "claude-string");
+        } else if (Array.isArray(block.content)) {
+
+          for (let k = 0; k < block.content.length; k++) {
+            const part = block.content[k];
+            if (part && part.type === "text" && typeof part.text === "string") {
+              part.text = compressText(part.text, stats, "claude-array");
+            }
+          }
+        }
+      }
+    }
+  } catch (e) {
+    console.warn("[RTK] compressMessages error:", e.message);
+    return null;
+  }
+  return stats;
+}
+
+function compressKiroFormat(body, enabled) {
+  const stats = { bytesBefore: 0, bytesAfter: 0, hits: [] };
+  try {
+    const state = body.conversationState;
+    const allMessages = [...(Array.isArray(state?.history) ? state.history : [])];
+    if (state?.currentMessage) allMessages.push(state.currentMessage);
+
+    for (const msg of allMessages) {
+      const toolResults = msg?.userInputMessage?.userInputMessageContext?.toolResults;
+      if (!Array.isArray(toolResults)) continue;
+
+      for (const tr of toolResults) {
+        if (tr.status === "error") continue;
+        if (!Array.isArray(tr.content)) continue;
+
+        for (const part of tr.content) {
+          if (part && typeof part.text === "string") {
+            part.text = compressText(part.text, stats, "kiro-tool-result");
+          }
+        }
+      }
+    }
+  } catch (e) {
+    console.warn("[RTK] compressKiroFormat error:", e.message);
+    return null;
+  }
+  return stats;
+}
+
+function compressText(text, stats, shape) {
+  const bytesIn = text.length;
+  stats.bytesBefore += bytesIn;
+
+  if (bytesIn < MIN_COMPRESS_SIZE || bytesIn > RAW_CAP) {
+    stats.bytesAfter += bytesIn;
+    return text;
+  }
+
+  const fn = autoDetectFilter(text);
+  if (!fn) {
+    stats.bytesAfter += bytesIn;
+    return text;
+  }
+
+  const out = safeApply(fn, text);
+
+  if (!out || out.length === 0 || out.length >= bytesIn) {
+    stats.bytesAfter += bytesIn;
+    return text;
+  }
+
+  stats.bytesAfter += out.length;
+  stats.hits.push({ shape, filter: fn.filterName || fn.name, saved: bytesIn - out.length });
+  return out;
+}
+
+export function formatRtkLog(stats) {
+  if (!stats || !stats.hits || stats.hits.length === 0) return null;
+  const saved = stats.bytesBefore - stats.bytesAfter;
+  const pct = stats.bytesBefore > 0 ? ((saved / stats.bytesBefore) * 100).toFixed(1) : "0";
+  const filters = Array.from(new Set(stats.hits.map(h => h.filter))).join(",");
+  return `[RTK] saved ${saved}B / ${stats.bytesBefore}B (${pct}%) via [${filters}] hits=${stats.hits.length}`;
+}

package/src/rtk/ponytail.js

@@ -0,0 +1,6 @@
+import { injectSystemPrompt } from "./systemInject.js";
+import { PONYTAIL_PROMPTS } from "./ponytailPrompt.js";
+
+export function injectPonytail(body, format, level) {
+  injectSystemPrompt(body, format, PONYTAIL_PROMPTS[level]);
+}

package/src/rtk/ponytailPrompt.js

@@ -0,0 +1,49 @@
+export const PONYTAIL_LEVELS = {
+  LITE: "lite",
+  FULL: "full",
+  ULTRA: "ultra",
+};
+
+const SHARED_PERSONA = "You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.";
+
+const SHARED_LADDER = "Before writing code, stop at the first rung that holds: 1) Does this need to exist at all? (YAGNI) 2) Stdlib does it? Use it. 3) Native platform feature covers it? Use it (CSS over JS, DB constraint over app code). 4) Already-installed dependency solves it? Use it; never add a new one for what a few lines can do. 5) Can it be one line? One line. 6) Only then: the minimum code that works.";
+
+const SHARED_RULES = "No unrequested abstractions (no interface with one implementation, no factory for one product, no config for a value that never changes). No boilerplate or scaffolding \"for later\". Deletion over addition. Boring over clever. Fewest files possible; shortest working diff wins. Two stdlib options the same size: take the edge-case-correct one. Mark deliberate simplifications with a `ponytail:` comment naming the ceiling and upgrade path.";
+
+const SHARED_OUTPUT = "Code first. Then at most three short lines: what was skipped, when to add it. No essays or design notes. Pattern: `[code] → skipped: [X], add when [Y].`";
+
+const SHARED_NOT_LAZY = "Never simplify away: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind (an assert-based self-check or one small test file; no frameworks). Trivial one-liners need no test.";
+
+const SHARED_PERSISTENCE = "ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if unsure.";
+
+export const PONYTAIL_PROMPTS = {
+  [PONYTAIL_LEVELS.LITE]: [
+    SHARED_PERSONA,
+    "Lite: build what's asked, but name the lazier alternative in one line. User picks.",
+    SHARED_LADDER,
+    SHARED_RULES,
+    SHARED_OUTPUT,
+    SHARED_NOT_LAZY,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+
+  [PONYTAIL_LEVELS.FULL]: [
+    SHARED_PERSONA,
+    "Full: the ladder enforced. Stdlib and native first. Shortest diff, shortest explanation.",
+    SHARED_LADDER,
+    SHARED_RULES,
+    SHARED_OUTPUT,
+    SHARED_NOT_LAZY,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+
+  [PONYTAIL_LEVELS.ULTRA]: [
+    SHARED_PERSONA,
+    "Ultra: YAGNI extremist. Deletion before addition. Ship the one-liner and challenge the rest of the requirement in the same response.",
+    SHARED_LADDER,
+    SHARED_RULES,
+    SHARED_OUTPUT,
+    SHARED_NOT_LAZY,
+    SHARED_PERSISTENCE,
+  ].join(" "),
+};

package/src/rtk/systemInject.js

@@ -0,0 +1,89 @@
+import { FORMATS } from "../translator/formats.js";
+
+const SEP = "\n\n";
+
+export function injectSystemPrompt(body, format, prompt) {
+  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:
+
+      injectGeminiSystem(body, prompt);
+      return;
+    default:
+
+      injectMessagesSystem(body, prompt);
+  }
+}
+
+function injectMessagesSystem(body, prompt) {
+
+  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)) {
+
+    msg.content.push({ type: "input_text", text: prompt });
+  } else {
+    msg.content = prompt;
+  }
+}
+
+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;
+}
+
+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 }] };
+}