recallnest 2.2.0 → 2.2.1

package/src/__tests__/temporal-parser.test.ts

@@ -1,241 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-  parseTemporalQuery,
-  matchesTemporalConstraint,
-  temporalWhereClause,
-  type TemporalConstraint,
-} from "../temporal-parser.js";
-
-// ============================================================================
-// parseTemporalQuery
-// ============================================================================
-
-describe("parseTemporalQuery", () => {
-  // --- Absolute year (ZH) ---
-  it("parses '2023年的记忆'", () => {
-    const result = parseTemporalQuery("2023年的记忆里有什么");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("range");
-    expect(result.constraint!.startMs).toBe(new Date(2023, 0, 1).getTime());
-    expect(result.constraint!.endMs).toBe(new Date(2024, 0, 1).getTime() - 1);
-    // Time expression removed from cleaned query
-    expect(result.cleanedQuery).not.toContain("2023年");
-    expect(result.cleanedQuery).toContain("里有什么");
-  });
-
-  it("parses standalone '2024年'", () => {
-    const result = parseTemporalQuery("关于 2024年 的项目");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("range");
-  });
-
-  // --- Absolute year+month (ZH) ---
-  it("parses '2023年3月'", () => {
-    const result = parseTemporalQuery("2023年3月我们讨论了什么");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.startMs).toBe(new Date(2023, 2, 1).getTime());
-    expect(result.constraint!.endMs).toBe(new Date(2023, 3, 1).getTime() - 1);
-  });
-
-  it("parses '2023年三月'", () => {
-    const result = parseTemporalQuery("2023年三月的对话");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.startMs).toBe(new Date(2023, 2, 1).getTime());
-  });
-
-  // --- Absolute year+month (EN) ---
-  it("parses 'March 2023'", () => {
-    const result = parseTemporalQuery("What did we discuss in March 2023");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.startMs).toBe(new Date(2023, 2, 1).getTime());
-    expect(result.constraint!.endMs).toBe(new Date(2023, 3, 1).getTime() - 1);
-  });
-
-  // --- "in YYYY" ---
-  it("parses 'in 2022'", () => {
-    const result = parseTemporalQuery("Projects discussed in 2022");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("range");
-    expect(result.constraint!.startMs).toBe(new Date(2022, 0, 1).getTime());
-  });
-
-  // --- Relative: 最近N天/周/月 ---
-  it("parses '最近7天'", () => {
-    const result = parseTemporalQuery("最近7天的记忆");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("range");
-    const now = Date.now();
-    expect(result.constraint!.startMs).toBeGreaterThan(now - 8 * 86_400_000);
-    expect(result.constraint!.endMs).toBeLessThanOrEqual(now + 1000);
-  });
-
-  it("parses '最近2周'", () => {
-    const result = parseTemporalQuery("最近2周讨论过什么");
-    expect(result.constraint).not.toBeNull();
-    const now = Date.now();
-    expect(result.constraint!.startMs).toBeGreaterThan(now - 15 * 86_400_000);
-  });
-
-  it("parses '最近3个月'", () => {
-    const result = parseTemporalQuery("最近3个月的项目进展");
-    expect(result.constraint).not.toBeNull();
-    const now = Date.now();
-    expect(result.constraint!.startMs).toBeGreaterThan(now - 100 * 86_400_000);
-  });
-
-  // --- Relative: last N days/weeks/months ---
-  it("parses 'last 30 days'", () => {
-    const result = parseTemporalQuery("What happened in the last 30 days");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("range");
-    const now = Date.now();
-    expect(result.constraint!.startMs).toBeGreaterThan(now - 31 * 86_400_000);
-  });
-
-  it("parses 'last 2 weeks'", () => {
-    const result = parseTemporalQuery("Changes in the last 2 weeks");
-    expect(result.constraint).not.toBeNull();
-  });
-
-  // --- Relative: 上周/上个月/去年 ---
-  it("parses '去年'", () => {
-    const result = parseTemporalQuery("去年我们做了什么项目");
-    expect(result.constraint).not.toBeNull();
-    const lastYear = new Date().getFullYear() - 1;
-    expect(result.constraint!.startMs).toBe(new Date(lastYear, 0, 1).getTime());
-    expect(result.constraint!.endMs).toBe(new Date(lastYear + 1, 0, 1).getTime() - 1);
-  });
-
-  it("parses 'last year'", () => {
-    const result = parseTemporalQuery("Projects from last year");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("range");
-  });
-
-  it("parses '上个月'", () => {
-    const result = parseTemporalQuery("上个月的讨论");
-    expect(result.constraint).not.toBeNull();
-  });
-
-  it("parses '去年3月'", () => {
-    const result = parseTemporalQuery("去年3月的事情");
-    expect(result.constraint).not.toBeNull();
-    const lastYear = new Date().getFullYear() - 1;
-    expect(result.constraint!.startMs).toBe(new Date(lastYear, 2, 1).getTime());
-  });
-
-  // --- Operator syntax ---
-  it("parses 'after:2024-01'", () => {
-    const result = parseTemporalQuery("TypeScript projects after:2024-01");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("after");
-    expect(result.constraint!.startMs).toBe(new Date(2024, 0, 1).getTime());
-    expect(result.cleanedQuery).toContain("TypeScript projects");
-  });
-
-  it("parses 'before:2025-06'", () => {
-    const result = parseTemporalQuery("memory entries before:2025-06");
-    expect(result.constraint).not.toBeNull();
-    expect(result.constraint!.type).toBe("before");
-  });
-
-  // --- No temporal expression ---
-  it("returns null for non-temporal queries", () => {
-    const result = parseTemporalQuery("How to configure TypeScript");
-    expect(result.constraint).toBeNull();
-    expect(result.cleanedQuery).toBe("How to configure TypeScript");
-  });
-
-  it("returns null for empty query", () => {
-    const result = parseTemporalQuery("");
-    expect(result.constraint).toBeNull();
-  });
-
-  // --- Cleaned query ---
-  it("removes temporal expression and preserves the rest", () => {
-    const result = parseTemporalQuery("2023年我们讨论了 Docker 配置");
-    expect(result.cleanedQuery).toContain("Docker");
-    expect(result.cleanedQuery).not.toContain("2023年");
-  });
-});
-
-// ============================================================================
-// matchesTemporalConstraint
-// ============================================================================
-
-describe("matchesTemporalConstraint", () => {
-  it("matches timestamp within range", () => {
-    const constraint: TemporalConstraint = {
-      type: "range",
-      startMs: new Date(2023, 0, 1).getTime(),
-      endMs: new Date(2024, 0, 1).getTime() - 1,
-      anchor: "2023年",
-    };
-    const mid2023 = new Date(2023, 6, 1).getTime();
-    expect(matchesTemporalConstraint(mid2023, constraint)).toBe(true);
-  });
-
-  it("rejects timestamp outside range", () => {
-    const constraint: TemporalConstraint = {
-      type: "range",
-      startMs: new Date(2023, 0, 1).getTime(),
-      endMs: new Date(2024, 0, 1).getTime() - 1,
-      anchor: "2023年",
-    };
-    const mid2022 = new Date(2022, 6, 1).getTime();
-    expect(matchesTemporalConstraint(mid2022, constraint)).toBe(false);
-  });
-
-  it("handles 'after' constraint", () => {
-    const constraint: TemporalConstraint = {
-      type: "after",
-      startMs: new Date(2024, 0, 1).getTime(),
-      anchor: "after:2024-01",
-    };
-    expect(matchesTemporalConstraint(new Date(2024, 6, 1).getTime(), constraint)).toBe(true);
-    expect(matchesTemporalConstraint(new Date(2023, 6, 1).getTime(), constraint)).toBe(false);
-  });
-
-  it("handles 'before' constraint", () => {
-    const constraint: TemporalConstraint = {
-      type: "before",
-      endMs: new Date(2024, 0, 1).getTime(),
-      anchor: "before:2024-01",
-    };
-    expect(matchesTemporalConstraint(new Date(2023, 6, 1).getTime(), constraint)).toBe(true);
-    expect(matchesTemporalConstraint(new Date(2025, 0, 1).getTime(), constraint)).toBe(false);
-  });
-});
-
-// ============================================================================
-// temporalWhereClause
-// ============================================================================
-
-describe("temporalWhereClause", () => {
-  it("generates range clause", () => {
-    const clause = temporalWhereClause({
-      type: "range",
-      startMs: 1000,
-      endMs: 2000,
-      anchor: "test",
-    });
-    expect(clause).toBe("timestamp >= 1000 AND timestamp <= 2000");
-  });
-
-  it("generates after-only clause", () => {
-    const clause = temporalWhereClause({
-      type: "after",
-      startMs: 1000,
-      anchor: "test",
-    });
-    expect(clause).toBe("timestamp >= 1000");
-  });
-
-  it("returns null for empty constraint", () => {
-    const clause = temporalWhereClause({
-      type: "range",
-      anchor: "test",
-    });
-    expect(clause).toBeNull();
-  });
-});

package/src/__tests__/temporal-validity.test.ts

@@ -1,160 +0,0 @@
-/**
- * F3: Temporal Validity Windows — tests for eventTime, validUntil,
- * retrieval filtering, and auto-GC decay acceleration.
- */
-
-import { describe, expect, test } from "bun:test";
-import {
-  defaultEvolution,
-  parseEvolution,
-  patchEvolution,
-  type EvolutionMetadata,
-} from "../memory-evolution.js";
-
-// ---------------------------------------------------------------------------
-// Schema: eventTime field
-// ---------------------------------------------------------------------------
-
-describe("F3: eventTime in EvolutionMetadata", () => {
-  test("defaultEvolution includes eventTime: null", () => {
-    const evo = defaultEvolution(1000);
-    expect(evo.eventTime).toBeNull();
-    expect(evo.validFrom).toBe(1000);
-    expect(evo.validUntil).toBeNull();
-  });
-
-  test("parseEvolution extracts eventTime from metadata", () => {
-    const metadata = JSON.stringify({
-      evolution: {
-        status: "active",
-        version: 1,
-        accessCount: 0,
-        lastAccessedAt: null,
-        supersededBy: null,
-        supersedes: null,
-        evolutionNote: null,
-        consolidatedInto: null,
-        contributedToPattern: null,
-        sourceMemories: [],
-        validFrom: 1000,
-        validUntil: null,
-        eventTime: 5000,
-      },
-    });
-    const evo = parseEvolution(metadata);
-    expect(evo.eventTime).toBe(5000);
-  });
-
-  test("parseEvolution defaults eventTime to null when missing", () => {
-    const metadata = JSON.stringify({
-      evolution: {
-        status: "active",
-        version: 1,
-        validFrom: 1000,
-      },
-    });
-    const evo = parseEvolution(metadata);
-    expect(evo.eventTime).toBeNull();
-  });
-
-  test("patchEvolution can set eventTime", () => {
-    const metadata = JSON.stringify({ evolution: defaultEvolution(1000) });
-    const patched = patchEvolution(metadata, { eventTime: 9999 });
-    const evo = parseEvolution(patched);
-    expect(evo.eventTime).toBe(9999);
-  });
-
-  test("patchEvolution can set validUntil", () => {
-    const metadata = JSON.stringify({ evolution: defaultEvolution(1000) });
-    const patched = patchEvolution(metadata, { validUntil: 2000 });
-    const evo = parseEvolution(patched);
-    expect(evo.validUntil).toBe(2000);
-    // Other fields unchanged
-    expect(evo.validFrom).toBe(1000);
-    expect(evo.status).toBe("active");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Retrieval: filterByValidity (unit-level via import)
-// ---------------------------------------------------------------------------
-
-// We test the filterByValidity logic indirectly through the exported
-// parseEvolution + the contract: expired memories get score * 0.2.
-// Direct integration tested via full retriever in separate test files.
-
-describe("F3: validity window logic", () => {
-  function makeEvo(overrides: Partial<EvolutionMetadata> = {}): EvolutionMetadata {
-    return { ...defaultEvolution(1000), ...overrides };
-  }
-
-  test("memory with validUntil in the future is not expired", () => {
-    const now = 5000;
-    const evo = makeEvo({ validUntil: 10000 });
-    // validUntil > now → not expired
-    expect(evo.validUntil).toBeGreaterThan(now);
-  });
-
-  test("memory with validUntil in the past is expired", () => {
-    const now = 5000;
-    const evo = makeEvo({ validUntil: 3000 });
-    // validUntil < now → expired
-    expect(evo.validUntil).toBeLessThan(now);
-  });
-
-  test("memory without validUntil never expires", () => {
-    const evo = makeEvo({ validUntil: null });
-    expect(evo.validUntil).toBeNull();
-  });
-
-  test("point-in-time query: memory valid in range", () => {
-    const evo = makeEvo({ validFrom: 1000, validUntil: 5000 });
-    const queryTime = 3000;
-    expect(evo.validFrom).toBeLessThanOrEqual(queryTime);
-    expect(evo.validUntil).toBeGreaterThanOrEqual(queryTime);
-  });
-
-  test("point-in-time query: memory not yet valid", () => {
-    const evo = makeEvo({ validFrom: 5000, validUntil: 10000 });
-    const queryTime = 3000;
-    expect(evo.validFrom).toBeGreaterThan(queryTime);
-  });
-
-  test("point-in-time query: memory already expired at query time", () => {
-    const evo = makeEvo({ validFrom: 1000, validUntil: 3000 });
-    const queryTime = 5000;
-    expect(evo.validUntil).toBeLessThan(queryTime);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Auto-GC: decay acceleration for expired memories
-// ---------------------------------------------------------------------------
-
-describe("F3: GC decay acceleration", () => {
-  test("expired memory decay score is halved", () => {
-    // Simulate the GC logic: if validUntil < now, decayScore *= 0.5
-    const baseDecayScore = 0.30;
-    const now = 10000;
-    const validUntil = 5000; // expired
-    const adjusted = validUntil < now ? baseDecayScore * 0.5 : baseDecayScore;
-    expect(adjusted).toBe(0.15);
-  });
-
-  test("non-expired memory decay score unchanged", () => {
-    const baseDecayScore = 0.30;
-    const now = 10000;
-    const validUntil = 20000; // still valid
-    const adjusted = validUntil < now ? baseDecayScore * 0.5 : baseDecayScore;
-    expect(adjusted).toBe(0.30);
-  });
-
-  test("memory without validUntil — decay score unchanged", () => {
-    const baseDecayScore = 0.30;
-    const validUntil = null;
-    const adjusted = (validUntil != null && validUntil < Date.now())
-      ? baseDecayScore * 0.5
-      : baseDecayScore;
-    expect(adjusted).toBe(0.30);
-  });
-});

package/src/__tests__/term-registry.test.ts

@@ -1,121 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  buildTaskHintTerms,
-  extractTerms,
-  looksLikeContinuityTask,
-  looksLikeRecallOnlyTask,
-  taskCueCoverage,
-} from "../term-registry.js";
-
-describe("term registry", () => {
-  it("extracts compact Chinese and latin cue terms", () => {
-    expect(extractTerms("继续 RecallNest continuity bridge 适配")).toEqual([
-      "继续",
-      "recallnest",
-      "continuity",
-      "bridge",
-      "适配",
-    ]);
-  });
-
-  it("can keep later terms when a wider extraction window is requested", () => {
-    expect(
-      extractTerms(
-        "继续 RecallNest continuity helper boundary audit ranking scoring selection orchestration context composer stable query fallback profile forwarding gap runner isolation",
-        24,
-      ),
-    ).toEqual(expect.arrayContaining([
-      "profile",
-      "forwarding",
-      "runner",
-      "isolation",
-    ]));
-  });
-
-  it("builds task hints for writing prompts across languages", () => {
-    expect(buildTaskHintTerms("continue my AI writing project")).toEqual([
-      "写作",
-      "文章",
-      "语气",
-      "风格",
-      "口语化",
-      "不端着",
-      "ai",
-      "公众号",
-    ]);
-  });
-
-  it("treats recall-only wording differently from writing actions", () => {
-    expect(looksLikeRecallOnlyTask("你还记得我之前的偏好吗")).toBe(true);
-    expect(looksLikeRecallOnlyTask("不要让我重复前情，继续写文章")).toBe(false);
-  });
-
-  it("tracks workflow cue coverage from pattern text", () => {
-    expect(
-      taskCueCoverage(
-        "patterns",
-        "Workflow pattern: Cross-window continuity handoff Tools: resume_context, checkpoint_session, search_memory",
-      ),
-    ).toEqual(["search_memory", "resume_context", "checkpoint"]);
-  });
-
-  it("treats named RecallNest and memory-layer continues as continuity tasks", () => {
-    expect(looksLikeContinuityTask("回到 RecallNest 继续做")).toBe(true);
-    expect(looksLikeContinuityTask("接着弄 RecallNest 那个 memory layer")).toBe(true);
-    expect(looksLikeContinuityTask("把记忆层这条线先续上")).toBe(true);
-    expect(looksLikeContinuityTask("把之前那套 recall 管线先捡起来")).toBe(true);
-    expect(looksLikeContinuityTask("pick up where we left off on RecallNest")).toBe(true);
-    expect(looksLikeContinuityTask("回到 A2A 继续做")).toBe(false);
-    // Status queries are NOT continuation tasks — entity+cases is sufficient
-    expect(looksLikeContinuityTask("RecallNest 现在啥情况")).toBe(false);
-  });
-
-  it("builds RecallNest continuity hints for memory-layer shorthand", () => {
-    expect(buildTaskHintTerms("把刚才那个 memory layer 接回去")).toEqual(expect.arrayContaining([
-      "recallnest",
-      "checkpoint_session",
-      "resume_context",
-      "store_memory",
-    ]));
-  });
-
-  it("builds RecallNest continuity hints for colloquial memory shorthand", () => {
-    expect(buildTaskHintTerms("把那条跨窗口记忆的活接着弄完")).toEqual(expect.arrayContaining([
-      "recallnest",
-      "checkpoint_session",
-      "resume_context",
-    ]));
-    expect(buildTaskHintTerms("把之前那套 recall 管线先捡起来")).toEqual(expect.arrayContaining([
-      "recallnest",
-      "checkpoint_session",
-      "resume_context",
-    ]));
-  });
-
-  it("treats 记忆项目 as continuity task and builds RecallNest hints", () => {
-    expect(looksLikeContinuityTask("那个记忆项目，之前做到哪了")).toBe(true);
-    expect(looksLikeContinuityTask("继续记忆项目")).toBe(true);
-    expect(buildTaskHintTerms("那个记忆项目，之前做到哪了")).toEqual(expect.arrayContaining([
-      "recallnest",
-      "resume_context",
-    ]));
-    expect(buildTaskHintTerms("continue the memory project")).toEqual(expect.arrayContaining([
-      "recallnest",
-    ]));
-  });
-
-  it("treats 跨终端记忆/记忆功能/记忆服务 shorthand as continuity cue", () => {
-    // "还搞吗" is a status question, not a continuation verb — correct to return false
-    expect(looksLikeContinuityTask("那个跨终端记忆还搞吗")).toBe(false);
-    expect(looksLikeContinuityTask("继续那个跨终端记忆")).toBe(true);
-    expect(looksLikeContinuityTask("上次做的那个记忆功能")).toBe(true);
-    expect(looksLikeContinuityTask("之前那个 MCP 记忆服务")).toBe(true);
-    expect(buildTaskHintTerms("那个跨终端记忆还搞吗")).toEqual(expect.arrayContaining([
-      "recallnest",
-    ]));
-    expect(buildTaskHintTerms("上次做的记忆功能")).toEqual(expect.arrayContaining([
-      "recallnest",
-    ]));
-  });
-});

package/src/__tests__/tool-output-compressor.test.ts

@@ -1,133 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { compressToolOutput } from "../tool-output-compressor.js";
-
-describe("compressToolOutput", () => {
-  // ========================================================================
-  // Base64 replacement
-  // ========================================================================
-
-  it("replaces large base64 blocks with size placeholder", () => {
-    const base64 = "A".repeat(2000);
-    const text = `Here is a screenshot:\n${base64}\nEnd of screenshot.`;
-    const result = compressToolOutput(text);
-    expect(result).toContain("[image:");
-    expect(result).toContain("base64");
-    expect(result).not.toContain("AAAA");
-  });
-
-  it("preserves short base64-like strings", () => {
-    const text = "The hash is abc123==";
-    expect(compressToolOutput(text)).toBe(text);
-  });
-
-  // ========================================================================
-  // Git output compression
-  // ========================================================================
-
-  it("compresses git push boilerplate", () => {
-    const text = `$ git push origin main
-Enumerating objects: 5, done.
-Counting objects: 100% (5/5), done.
-Delta compression using up to 8 threads
-Compressing objects: 100% (3/3), done.
-Writing objects: 100% (3/3), 450 bytes | 450.00 KiB/s, done.
-Total 3 (delta 2), reused 0 (delta 0)
-remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
-To github.com:user/repo.git
-   abc1234..def5678  main -> main
-
-Next I'll check the status.`;
-
-    const result = compressToolOutput(text);
-    expect(result).toContain("[git: ok");
-    expect(result).toContain("main");
-    expect(result).not.toContain("Enumerating objects");
-    expect(result).toContain("Next I'll check the status");
-  });
-
-  it("preserves git push failures", () => {
-    const text = `$ git push
-Enumerating objects: 5, done.
-error: failed to push some refs to 'origin'
-hint: Updates were rejected because the tip of your branch is behind -> main`;
-
-    const result = compressToolOutput(text);
-    expect(result).toContain("error");
-    expect(result).toContain("rejected");
-  });
-
-  // ========================================================================
-  // Test output compression
-  // ========================================================================
-
-  it("compresses passing test summary", () => {
-    const text = `$ bun test
-running 15 tests
-test a ... ok
-test b ... ok
-test c ... ok
-test result: ok. 15 passed; 0 failed; 0 ignored
-
-All tests passed.`;
-
-    const result = compressToolOutput(text);
-    expect(result.length).toBeLessThanOrEqual(text.length);
-    expect(result).toContain("All tests passed");
-  });
-
-  it("preserves failing test output", () => {
-    const text = `$ npm test
-Tests: 2 failed, 8 passed
-FAIL src/main.test.ts
-  ✕ should handle edge case`;
-
-    const result = compressToolOutput(text);
-    expect(result).toContain("failed");
-    expect(result).toContain("FAIL");
-  });
-
-  // ========================================================================
-  // Safety: user/AI content untouched
-  // ========================================================================
-
-  it("never modifies plain conversation text", () => {
-    const text = "User: How do I fix this git push error?\n\nAssistant: You need to pull first.";
-    expect(compressToolOutput(text)).toBe(text);
-  });
-
-  it("preserves AI reasoning about tool results", () => {
-    const text = "The test result shows 15 passed, which means our fix works.";
-    expect(compressToolOutput(text)).toBe(text);
-  });
-
-  // ========================================================================
-  // Edge cases
-  // ========================================================================
-
-  it("handles empty input", () => {
-    expect(compressToolOutput("")).toBe("");
-  });
-
-  it("handles short input", () => {
-    expect(compressToolOutput("hi")).toBe("hi");
-  });
-
-  it("handles text without tool outputs", () => {
-    const text = "This is a normal conversation.\nNo tool outputs here.";
-    expect(compressToolOutput(text)).toBe(text);
-  });
-
-  // ========================================================================
-  // Large output truncation
-  // ========================================================================
-
-  it("truncates large unmatched tool output", () => {
-    // Use content with spaces/special chars to avoid base64 regex match
-    const largeOutput = Array.from({ length: 150 }, (_, i) => `line ${i}: some detailed output here`).join("\n");
-    const text = `$ some-command\n${largeOutput}\n\nNext step.`;
-    const result = compressToolOutput(text);
-    expect(result).toContain("[...");
-    expect(result).toContain("chars truncated");
-    expect(result.length).toBeLessThan(text.length);
-  });
-});