karajan-code 1.58.1 → 1.59.0

package/src/proxy/compression/ai-compressor.js

@@ -0,0 +1,209 @@
+/**
+ * Optional AI-powered compression for content that remains large
+ * after deterministic compression.
+ * Calls a cheap LLM model to summarize old tool results while
+ * preserving key data (file paths, error messages, numbers, status codes).
+ *
+ * Disabled by default. Enable via config: { enabled: true, provider, apiKey }.
+ * Zero external dependencies — uses vanilla Node.js https module.
+ */
+import https from "node:https";
+
+// ---------------------------------------------------------------------------
+// Provider definitions
+// ---------------------------------------------------------------------------
+const PROVIDERS = {
+  anthropic: {
+    hostname: "api.anthropic.com",
+    path: "/v1/messages",
+    defaultModel: "claude-3-5-haiku-20241022",
+    costPerInputToken: 0.25 / 1_000_000,
+    costPerOutputToken: 1.25 / 1_000_000,
+    buildRequest(text, model, apiKey, maxOutputTokens) {
+      const body = JSON.stringify({
+        model,
+        max_tokens: maxOutputTokens,
+        messages: [{ role: "user", content: buildPrompt(text) }]
+      });
+      return {
+        hostname: this.hostname,
+        path: this.path,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body
+      };
+    },
+    parseResponse(data) {
+      const content = data.content?.[0]?.text ?? "";
+      const input = data.usage?.input_tokens ?? 0;
+      const output = data.usage?.output_tokens ?? 0;
+      return { text: content, tokensUsed: { input, output } };
+    }
+  },
+
+  openai: {
+    hostname: "api.openai.com",
+    path: "/v1/chat/completions",
+    defaultModel: "gpt-4o-mini",
+    costPerInputToken: 0.15 / 1_000_000,
+    costPerOutputToken: 0.6 / 1_000_000,
+    buildRequest(text, model, apiKey, maxOutputTokens) {
+      const body = JSON.stringify({
+        model,
+        max_tokens: maxOutputTokens,
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: text }
+        ]
+      });
+      return {
+        hostname: this.hostname,
+        path: this.path,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body
+      };
+    },
+    parseResponse(data) {
+      const content = data.choices?.[0]?.message?.content ?? "";
+      const input = data.usage?.prompt_tokens ?? 0;
+      const output = data.usage?.completion_tokens ?? 0;
+      return { text: content, tokensUsed: { input, output } };
+    }
+  },
+
+  gemini: {
+    hostname: "generativelanguage.googleapis.com",
+    defaultModel: "gemini-2.0-flash-lite",
+    costPerInputToken: 0.075 / 1_000_000,
+    costPerOutputToken: 0.3 / 1_000_000,
+    buildRequest(text, model, apiKey, maxOutputTokens) {
+      const path = `/v1beta/models/${model}:generateContent?key=${apiKey}`;
+      const body = JSON.stringify({
+        contents: [{ parts: [{ text: buildPrompt(text) }] }],
+        generationConfig: { maxOutputTokens }
+      });
+      return {
+        hostname: this.hostname,
+        path,
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body
+      };
+    },
+    parseResponse(data) {
+      const content = data.candidates?.[0]?.content?.parts?.[0]?.text ?? "";
+      const input = data.usageMetadata?.promptTokenCount ?? 0;
+      const output = data.usageMetadata?.candidatesTokenCount ?? 0;
+      return { text: content, tokensUsed: { input, output } };
+    }
+  }
+};
+
+// ---------------------------------------------------------------------------
+// Prompt
+// ---------------------------------------------------------------------------
+const SYSTEM_PROMPT =
+  "You are a compression assistant. Summarize the following tool output concisely " +
+  "while preserving ALL: file paths, error messages, numbers, status codes, " +
+  "exit codes, and key technical details. Remove boilerplate, repeated lines, " +
+  "and verbose formatting. Output only the summary, no preamble.";
+
+function buildPrompt(text) {
+  return `${SYSTEM_PROMPT}\n\n---\n${text}`;
+}
+
+// ---------------------------------------------------------------------------
+// HTTPS helper
+// ---------------------------------------------------------------------------
+function httpsRequest({ hostname, path, method, headers, body }) {
+  return new Promise((resolve, reject) => {
+    const req = https.request({ hostname, path, method, headers }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        const raw = Buffer.concat(chunks).toString();
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          reject(new Error(`HTTP ${res.statusCode}: ${raw}`));
+          return;
+        }
+        try {
+          resolve(JSON.parse(raw));
+        } catch (err) {
+          reject(new Error(`Invalid JSON response: ${raw.slice(0, 200)}`));
+        }
+      });
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Check whether AI compression can be used with the given config.
+ * @param {{ enabled?: boolean, provider?: string, apiKey?: string }} config
+ * @returns {boolean}
+ */
+export function isAICompressionAvailable(config) {
+  if (!config || !config.enabled) return false;
+  const provider = config.provider ?? "anthropic";
+  if (!PROVIDERS[provider]) return false;
+  return Boolean(config.apiKey);
+}
+
+/**
+ * Compress text using a cheap LLM model.
+ * @param {string} text - text to compress
+ * @param {{ model?: string, apiKey?: string, provider?: string, maxOutputTokens?: number, enabled?: boolean }} options
+ * @returns {Promise<{ compressed: string, tokensUsed: { input: number, output: number }, cost: number }>}
+ */
+export async function compressWithAI(text, options = {}) {
+  const { enabled = false, provider: providerName = "anthropic", apiKey, maxOutputTokens = 1024 } = options;
+
+  // Disabled mode — return original text unchanged
+  if (!enabled || !apiKey) {
+    return { compressed: text, tokensUsed: { input: 0, output: 0 }, cost: 0 };
+  }
+
+  const provider = PROVIDERS[providerName];
+  if (!provider) {
+    return { compressed: text, tokensUsed: { input: 0, output: 0 }, cost: 0 };
+  }
+
+  const model = options.model ?? provider.defaultModel;
+
+  try {
+    const reqOpts = provider.buildRequest(text, model, apiKey, maxOutputTokens);
+    const data = await httpsRequest(reqOpts);
+    const { text: compressed, tokensUsed } = provider.parseResponse(data);
+
+    if (!compressed) {
+      return { compressed: text, tokensUsed: { input: 0, output: 0 }, cost: 0 };
+    }
+
+    const cost =
+      tokensUsed.input * provider.costPerInputToken +
+      tokensUsed.output * provider.costPerOutputToken;
+
+    return { compressed, tokensUsed, cost };
+  } catch {
+    // Graceful degradation — return original text on any failure
+    return { compressed: text, tokensUsed: { input: 0, output: 0 }, cost: 0 };
+  }
+}
+
+/** Exported for testing */
+export { PROVIDERS };

package/src/proxy/compression/dedup-cache.js

@@ -0,0 +1,100 @@
+import { createHash } from "node:crypto";
+
+/**
+ * Cross-turn content deduplication using an LRU hash cache.
+ * Detects repeated content across conversation turns and returns
+ * compact references instead of duplicated text.
+ */
+export class DedupCache {
+  #maxEntries;
+  #cache; // Map preserves insertion order for LRU
+  #totalChecks;
+  #hits;
+  #misses;
+
+  constructor({ maxEntries = 500 } = {}) {
+    this.#maxEntries = maxEntries;
+    this.#cache = new Map();
+    this.#totalChecks = 0;
+    this.#hits = 0;
+    this.#misses = 0;
+  }
+
+  /**
+   * Check if text has been seen in a prior turn.
+   * @param {string} text - Content to check
+   * @param {number} turnIndex - Current turn number
+   * @returns {{isDuplicate: boolean, reference?: string}}
+   */
+  check(text, turnIndex) {
+    this.#totalChecks++;
+
+    const tokenCount = Math.floor(text.length / 4);
+    const hash = createHash("sha256").update(text).digest("hex");
+    const shortHash = hash.slice(0, 6);
+
+    // Small content is never deduped
+    if (tokenCount <= 200) {
+      this.#misses++;
+      this.#upsert(hash, { hash, turnIndex, tokenCount, insertedAt: Date.now() });
+      return { isDuplicate: false };
+    }
+
+    const existing = this.#cache.get(hash);
+
+    if (existing && existing.turnIndex < turnIndex) {
+      // Seen in a prior turn — duplicate
+      this.#hits++;
+      // Refresh LRU position
+      this.#cache.delete(hash);
+      this.#cache.set(hash, { ...existing, insertedAt: Date.now() });
+      return {
+        isDuplicate: true,
+        reference: `[Content from turn ${existing.turnIndex}, hash ${shortHash}, ${tokenCount} tokens - unchanged]`,
+      };
+    }
+
+    // Not seen or same turn — store and return not duplicate
+    this.#misses++;
+    this.#upsert(hash, { hash, turnIndex, tokenCount, insertedAt: Date.now() });
+    return { isDuplicate: false };
+  }
+
+  /**
+   * Insert or update an entry, evicting the oldest if at capacity.
+   */
+  #upsert(key, entry) {
+    // If key already exists, delete first to refresh insertion order
+    if (this.#cache.has(key)) {
+      this.#cache.delete(key);
+    }
+
+    // Evict oldest (first inserted) if at capacity
+    if (this.#cache.size >= this.#maxEntries) {
+      const oldestKey = this.#cache.keys().next().value;
+      this.#cache.delete(oldestKey);
+    }
+
+    this.#cache.set(key, entry);
+  }
+
+  /**
+   * @returns {{totalChecks: number, hits: number, misses: number, entries: number}}
+   */
+  getStats() {
+    return {
+      totalChecks: this.#totalChecks,
+      hits: this.#hits,
+      misses: this.#misses,
+      entries: this.#cache.size,
+    };
+  }
+
+  /** Clear all state (call between sessions). */
+  reset() {
+    this.#cache.clear();
+    this.#totalChecks = 0;
+    this.#hits = 0;
+    this.#misses = 0;
+  }
+}

package/src/proxy/compression/deterministic/bash-build.js

@@ -0,0 +1,60 @@
+/**
+ * Deterministic compression for build tool output.
+ * Handles: tsc, eslint, prettier, next build, webpack, vite build.
+ */
+import { stripAnsi, collapseWhitespace, truncateLines } from "./utils.js";
+
+const BUILD_PATTERNS = [
+  /error TS\d+:/,
+  /\d+ errors?/i,
+  /\d+ warnings?/i,
+  /eslint/i,
+  /prettier/i,
+  /webpack/i,
+  /✔|Built in|compiled/i,
+  /Module Error|SyntaxError|TypeError/,
+  /next build|vite build/i
+];
+
+export function looksLike(text) {
+  const clean = stripAnsi(text);
+  return BUILD_PATTERNS.some((p) => p.test(clean));
+}
+
+export function compact(text) {
+  const clean = stripAnsi(text);
+  const lines = clean.split("\n");
+
+  // Collect error/warning lines and summary lines
+  const errors = [];
+  const warnings = [];
+  const summaries = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    if (/error TS\d+:|Error:|SyntaxError:|TypeError:|Module Error/i.test(trimmed)) {
+      errors.push(trimmed);
+    } else if (/warning|warn\b/i.test(trimmed) && !/node_modules/.test(trimmed)) {
+      warnings.push(trimmed);
+    } else if (/\d+ errors?|\d+ warnings?|compiled|Built in|✔|Found \d+/i.test(trimmed)) {
+      summaries.push(trimmed);
+    }
+  }
+
+  const parts = [];
+  if (errors.length) {
+    parts.push(`Errors (${errors.length}):\n${truncateLines(errors.join("\n"), 20)}`);
+  }
+  if (warnings.length) {
+    parts.push(`Warnings (${warnings.length}):\n${truncateLines(warnings.join("\n"), 10)}`);
+  }
+  if (summaries.length) {
+    parts.push(summaries.join("\n"));
+  }
+
+  if (parts.length) return parts.join("\n\n");
+
+  return truncateLines(collapseWhitespace(clean), 40);
+}

package/src/proxy/compression/deterministic/bash-git.js

@@ -0,0 +1,101 @@
+/**
+ * Deterministic compression for git CLI output.
+ * Handles: git status, git diff, git log, git branch.
+ */
+import { stripAnsi, collapseWhitespace, truncateLines } from "./utils.js";
+
+const GIT_PATTERNS = [
+  /^On branch /m,
+  /^(modified|deleted|new file|renamed):/m,
+  /^Untracked files:/m,
+  /^diff --git/m,
+  /^commit [0-9a-f]{7,40}/m,
+  /^(Changes to be committed|Changes not staged)/m,
+  /^\* /m // git branch current branch marker
+];
+
+export function looksLike(text) {
+  const clean = stripAnsi(text);
+  return GIT_PATTERNS.some((p) => p.test(clean));
+}
+
+export function compact(text) {
+  const clean = stripAnsi(text);
+
+  // git status
+  if (/^On branch /m.test(clean) || /Changes (to be committed|not staged)/m.test(clean)) {
+    return compactStatus(clean);
+  }
+  // git diff
+  if (/^diff --git/m.test(clean)) {
+    return compactDiff(clean);
+  }
+  // git log
+  if (/^commit [0-9a-f]{7,40}/m.test(clean)) {
+    return compactLog(clean);
+  }
+  // git branch
+  if (/^\* /m.test(clean) && clean.split("\n").every((l) => /^[\s*]/.test(l) || !l.trim())) {
+    return compactBranch(clean);
+  }
+  return collapseWhitespace(clean);
+}
+
+function compactStatus(text) {
+  const lines = text.split("\n");
+  const kept = [];
+  const branchLine = lines.find((l) => l.startsWith("On branch "));
+  if (branchLine) kept.push(branchLine);
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (
+      /^(modified|deleted|new file|renamed|both modified):/.test(trimmed) ||
+      /^(Untracked files|Changes to be committed|Changes not staged)/.test(trimmed)
+    ) {
+      kept.push(trimmed);
+    }
+  }
+  return kept.join("\n") || text;
+}
+
+function compactDiff(text) {
+  const files = text.split(/(?=^diff --git)/m);
+  const summaries = [];
+  for (const file of files) {
+    if (!file.trim()) continue;
+    const header = file.match(/^diff --git a\/(.+?) b\/(.+)/m);
+    const fname = header ? header[2] : "unknown";
+    const additions = (file.match(/^\+(?!\+\+)/gm) || []).length;
+    const deletions = (file.match(/^-(?!--)/gm) || []).length;
+    const hunkHeaders = file.match(/^@@.*@@.*$/gm) || [];
+    summaries.push(`${fname}: +${additions}/-${deletions} (${hunkHeaders.length} hunks)`);
+
+    // Keep first few hunk headers for context
+    for (const h of hunkHeaders.slice(0, 3)) {
+      summaries.push(`  ${h.trim()}`);
+    }
+  }
+  return `git diff summary (${files.filter((f) => f.trim()).length} files):\n${summaries.join("\n")}`;
+}
+
+function compactLog(text) {
+  const entries = text.split(/(?=^commit )/m).filter((e) => e.trim());
+  const lines = [];
+  for (const entry of entries) {
+    const hashMatch = entry.match(/^commit ([0-9a-f]{7})/);
+    const msgMatch = entry.match(/^\s{4}(.+)/m);
+    const hash = hashMatch ? hashMatch[1] : "???????";
+    const msg = msgMatch ? msgMatch[1].trim() : "(no message)";
+    lines.push(`${hash} ${msg}`);
+  }
+  return truncateLines(lines.join("\n"), 30);
+}
+
+function compactBranch(text) {
+  const lines = text.split("\n").filter((l) => l.trim());
+  if (lines.length <= 20) return lines.map((l) => l.trim()).join("\n");
+  const current = lines.find((l) => l.startsWith("*"));
+  const count = lines.length;
+  return `${current ? current.trim() : "(detached)"}\n... (${count} branches total)`;
+}

package/src/proxy/compression/deterministic/bash-infra.js

@@ -0,0 +1,64 @@
+/**
+ * Deterministic compression for infrastructure CLI output.
+ * Handles: docker ps/images/logs, kubectl, terraform plan/apply.
+ */
+import { stripAnsi, collapseWhitespace, truncateLines } from "./utils.js";
+
+const INFRA_PATTERNS = [
+  /CONTAINER ID/,
+  /REPOSITORY\s+TAG/,
+  /^NAME\s+READY\s+STATUS/m,
+  /^(kubectl|docker|terraform)\s/m,
+  /Terraform will perform/,
+  /Plan:\s+\d+ to add/,
+  /Apply complete/
+];
+
+export function looksLike(text) {
+  const clean = stripAnsi(text);
+  return INFRA_PATTERNS.some((p) => p.test(clean));
+}
+
+export function compact(text) {
+  const clean = stripAnsi(text);
+
+  // docker ps / docker images — compact table
+  if (/CONTAINER ID/.test(clean) || /REPOSITORY\s+TAG/.test(clean)) {
+    return compactTable(clean);
+  }
+
+  // terraform plan/apply
+  if (/Terraform will perform|Plan:\s+\d+|Apply complete/.test(clean)) {
+    return compactTerraform(clean);
+  }
+
+  // kubectl — compact table
+  if (/^NAME\s+READY\s+STATUS/m.test(clean)) {
+    return compactTable(clean);
+  }
+
+  // docker logs — truncate
+  return truncateLines(collapseWhitespace(clean), 30);
+}
+
+function compactTable(text) {
+  const lines = text.split("\n").filter((l) => l.trim());
+  if (lines.length <= 15) return lines.map((l) => collapseWhitespace(l)).join("\n");
+  const header = lines[0];
+  const rows = lines.slice(1, 11);
+  return `${collapseWhitespace(header)}\n${rows.map((r) => collapseWhitespace(r)).join("\n")}\n... (${lines.length - 1} total rows)`;
+}
+
+function compactTerraform(text) {
+  const lines = text.split("\n");
+  const kept = [];
+  for (const line of lines) {
+    if (
+      /Plan:|Apply complete|Terraform will perform|^\s*[#~+-]/.test(line) &&
+      !/Refreshing state/.test(line)
+    ) {
+      kept.push(line.trim());
+    }
+  }
+  return truncateLines(kept.join("\n"), 40) || truncateLines(collapseWhitespace(text), 30);
+}

package/src/proxy/compression/deterministic/bash-misc.js

@@ -0,0 +1,53 @@
+/**
+ * Deterministic compression for miscellaneous Bash output.
+ * Handles: curl/wget, gh CLI, npx, general long output.
+ */
+import { stripAnsi, collapseWhitespace, truncateLines } from "./utils.js";
+
+const MISC_PATTERNS = [
+  /HTTP\/[\d.]+\s+\d{3}/,
+  /curl:|wget:/i,
+  /gh (pr|issue|repo|release)/i,
+  /npx:/i
+];
+
+export function looksLike(text) {
+  const clean = stripAnsi(text);
+  return MISC_PATTERNS.some((p) => p.test(clean));
+}
+
+export function compact(text) {
+  const clean = stripAnsi(text);
+
+  // curl/wget — keep status + relevant headers
+  if (/HTTP\/[\d.]+\s+\d{3}/.test(clean)) {
+    return compactHttp(clean);
+  }
+
+  // gh CLI — compact lists
+  if (/gh (pr|issue|repo|release)/i.test(clean)) {
+    return truncateLines(collapseWhitespace(clean), 20);
+  }
+
+  return truncateLines(collapseWhitespace(clean), 40);
+}
+
+function compactHttp(text) {
+  const lines = text.split("\n");
+  const kept = [];
+  for (const line of lines) {
+    if (
+      /HTTP\/[\d.]+\s+\d{3}/.test(line) ||
+      /^(content-type|location|x-[-\w]+|authorization):/i.test(line.trim())
+    ) {
+      kept.push(line.trim());
+    }
+  }
+  // Also keep body, truncated
+  const bodyStart = text.indexOf("\r\n\r\n");
+  if (bodyStart > -1) {
+    const body = text.slice(bodyStart + 4).trim();
+    if (body) kept.push(truncateLines(body, 20));
+  }
+  return kept.join("\n") || truncateLines(collapseWhitespace(text), 30);
+}

package/src/proxy/compression/deterministic/bash-pkg.js

@@ -0,0 +1,49 @@
+/**
+ * Deterministic compression for package manager output.
+ * Handles: npm/yarn/pnpm install, npm list, npm outdated.
+ */
+import { stripAnsi, collapseWhitespace, truncateLines } from "./utils.js";
+
+const PKG_PATTERNS = [
+  /added \d+ packages?/i,
+  /npm warn|npm error/i,
+  /packages? in \d/,
+  /├──|└──|│/,
+  /\d+ vulnerabilities/i,
+  /npm outdated/i,
+  /Current\s+Wanted\s+Latest/i
+];
+
+export function looksLike(text) {
+  const clean = stripAnsi(text);
+  return PKG_PATTERNS.some((p) => p.test(clean));
+}
+
+export function compact(text) {
+  const clean = stripAnsi(text);
+
+  // npm install summary
+  if (/added \d+ packages?/i.test(clean)) {
+    const lines = clean.split("\n");
+    const kept = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (/added \d+ packages?/i.test(trimmed) || /vulnerabilit/i.test(trimmed)) {
+        kept.push(trimmed);
+      }
+    }
+    return kept.join("\n") || clean;
+  }
+
+  // npm list — truncate tree
+  if (/├──|└──/.test(clean)) {
+    return truncateLines(clean, 25);
+  }
+
+  // npm outdated — compact table
+  if (/Current\s+Wanted\s+Latest/i.test(clean)) {
+    return truncateLines(collapseWhitespace(clean), 20);
+  }
+
+  return truncateLines(collapseWhitespace(clean), 30);
+}

package/src/proxy/compression/deterministic/bash-test.js

@@ -0,0 +1,61 @@
+/**
+ * Deterministic compression for test runner output.
+ * Handles: vitest, jest, mocha, playwright, pytest, cargo test, go test.
+ */
+import { stripAnsi, collapseWhitespace, truncateLines } from "./utils.js";
+
+const TEST_PATTERNS = [
+  /Tests?\s+\d+\s+(passed|failed)/i,
+  /✓|✗|✘|PASS|FAIL/,
+  /Test Suites?:/,
+  /test result:/i,
+  /FAILED|PASSED|ERROR/,
+  /vitest|jest|mocha|playwright|pytest|cargo test|go test/i,
+  /\d+ passing/,
+  /\d+ failing/
+];
+
+export function looksLike(text) {
+  const clean = stripAnsi(text);
+  return TEST_PATTERNS.some((p) => p.test(clean));
+}
+
+export function compact(text) {
+  const clean = stripAnsi(text);
+
+  // Extract summary line if present
+  const summaryPatterns = [
+    /Tests?\s+\d+\s+(passed|failed).*/gi,
+    /Test Suites?:.*$/gm,
+    /\d+ passing.*$/gm,
+    /\d+ failing.*$/gm,
+    /test result:.*$/gim,
+    /Tests:.*\d+ total$/gm
+  ];
+
+  const summaries = [];
+  for (const p of summaryPatterns) {
+    const matches = clean.match(p);
+    if (matches) summaries.push(...matches.map((m) => m.trim()));
+  }
+
+  // Extract failed test details (name + error)
+  const failures = [];
+  const failBlocks = clean.split(/(?=(?:FAIL|✗|✘|×)\s)/);
+  for (const block of failBlocks) {
+    if (/^(?:FAIL|✗|✘|×)\s/.test(block)) {
+      failures.push(truncateLines(block.trim(), 8));
+    }
+  }
+
+  const parts = [];
+  if (summaries.length) parts.push(summaries.join("\n"));
+  if (failures.length) {
+    parts.push(`Failed tests:\n${failures.join("\n---\n")}`);
+  }
+
+  if (parts.length) return parts.join("\n\n");
+
+  // Fallback: collapse and truncate
+  return truncateLines(collapseWhitespace(clean), 50);
+}