big-rag-rus

import { describe, test } from "node:test";
import assert from "node:assert/strict";
import {
  extractFilenameSearchIntent,
  hasContentDisplayIntent,
} from "../promptPreprocessor";

describe("extractFilenameSearchIntent", () => {
  // ─── Russian queries ──────────────────────────────────────────────────

  test("detects 'найди файл TestFormat' as filename-only search", () => {
    const result = extractFilenameSearchIntent("найди файл TestFormat");
    assert.ok(result.filenameKeywords.length > 0, "Should detect filename keywords");
    assert.ok(
      result.filenameKeywords.some(k => k.toLowerCase().includes("testformat")),
      `Expected 'TestFormat' in keywords, got: ${result.filenameKeywords.join(", ")}`,
    );
    assert.equal(result.isFilenameOnly, true, "Should be filename-only");
    assert.equal(result.contentKeywords.length, 0, "Should have no content keywords");
  });

  test("detects 'найди все файлы протокол' as filename-only search", () => {
    const result = extractFilenameSearchIntent("найди все файлы протокол");
    assert.ok(result.filenameKeywords.length > 0, "Should detect filename keywords");
    assert.ok(
      result.filenameKeywords.some(k => k.toLowerCase().includes("протокол")),
      `Expected 'протокол' in keywords, got: ${result.filenameKeywords.join(", ")}`,
    );
    assert.equal(result.isFilenameOnly, true);
  });

  test("detects 'найди файлы с именем письмо' as filename-only search", () => {
    const result = extractFilenameSearchIntent("найди файлы с именем письмо");
    assert.ok(result.filenameKeywords.length > 0);
    assert.ok(
      result.filenameKeywords.some(k => k.toLowerCase().includes("письмо")),
      `Expected 'письмо' in keywords, got: ${result.filenameKeywords.join(", ")}`,
    );
    assert.equal(result.isFilenameOnly, true);
  });

  test("detects 'в названии которых есть отчёт' as filename search", () => {
    const result = extractFilenameSearchIntent("в названии которых есть отчёт");
    assert.ok(result.filenameKeywords.length > 0);
    assert.ok(
      result.filenameKeywords.some(k => k.toLowerCase().includes("отчёт")),
      `Expected 'отчёт' in keywords, got: ${result.filenameKeywords.join(", ")}`,
    );
    assert.equal(result.isFilenameOnly, true);
  });

  test("detects 'найди файлы письмо в которых встречается слово договор' as filename+content", () => {
    const result = extractFilenameSearchIntent(
      "найди файлы письмо в которых встречается слово договор",
    );
    assert.ok(result.filenameKeywords.length > 0, "Should have filename keywords");
    assert.equal(result.isFilenameOnly, false, "Should NOT be filename-only");
    assert.ok(
      result.contentKeywords.length > 0,
      "Should have content keywords",
    );
    assert.ok(
      result.contentKeywords.some(k => k.toLowerCase().includes("договор")),
      `Expected 'договор' in content keywords, got: ${result.contentKeywords.join(", ")}`,
    );
  });

  test("returns empty for regular question without filename intent", () => {
    const result = extractFilenameSearchIntent("расскажи о системе управления базами данных");
    assert.equal(result.filenameKeywords.length, 0, "Should have no filename keywords");
    assert.equal(result.contentKeywords.length, 0, "Should have no content keywords");
    assert.equal(result.isFilenameOnly, false);
  });

  test("returns empty for simple greeting", () => {
    const result = extractFilenameSearchIntent("привет, как дела?");
    assert.equal(result.filenameKeywords.length, 0);
  });

  // ─── English queries ──────────────────────────────────────────────────

  test("detects 'find files named protocol' as filename-only search", () => {
    const result = extractFilenameSearchIntent("find files named protocol");
    assert.ok(result.filenameKeywords.length > 0);
    assert.ok(
      result.filenameKeywords.some(k => k.toLowerCase().includes("protocol")),
      `Expected 'protocol' in keywords, got: ${result.filenameKeywords.join(", ")}`,
    );
    assert.equal(result.isFilenameOnly, true);
  });

  test("detects 'find all files report' as filename-only search", () => {
    const result = extractFilenameSearchIntent("find all files report");
    assert.ok(result.filenameKeywords.length > 0);
    assert.ok(
      result.filenameKeywords.some(k => k.toLowerCase().includes("report")),
      `Expected 'report' in keywords, got: ${result.filenameKeywords.join(", ")}`,
    );
    assert.equal(result.isFilenameOnly, true);
  });

  test("detects 'show files called report containing budget' — containing/budget become filename keywords", () => {
    // NOTE: "containing" is not a recognized content-keyword separator in English patterns,
    // so "budget" ends up as a filename keyword. This is a known limitation.
    const result = extractFilenameSearchIntent("show files called report containing budget");
    assert.ok(result.filenameKeywords.length > 0);
    // "report" should be detected as a filename keyword
    assert.ok(
      result.filenameKeywords.some(k => k.toLowerCase().includes("report")),
      `Expected 'report' in keywords, got: ${result.filenameKeywords.join(", ")}`,
    );
  });

  test("detects 'list files with name invoice' as filename-only", () => {
    const result = extractFilenameSearchIntent("list files with name invoice");
    assert.ok(result.filenameKeywords.length > 0);
    assert.ok(
      result.filenameKeywords.some(k => k.toLowerCase().includes("invoice")),
      `Expected 'invoice' in keywords, got: ${result.filenameKeywords.join(", ")}`,
    );
    assert.equal(result.isFilenameOnly, true);
  });

  test("returns empty for English question without filename intent", () => {
    const result = extractFilenameSearchIntent("What is the capital of France?");
    assert.equal(result.filenameKeywords.length, 0);
  });
});

describe("hasContentDisplayIntent", () => {
  // ─── Russian queries with content intent ───────────────────────────────

  test("returns true for 'выведи полностью его содержание'", () => {
    assert.equal(
      hasContentDisplayIntent("найди файл TestFormat и выведи полностью его содержание"),
      true,
    );
  });

  test("returns true for 'выведи'", () => {
    assert.equal(hasContentDisplayIntent("выведи содержимое файла"), true);
  });

  test("returns true for 'прочитай'", () => {
    assert.equal(hasContentDisplayIntent("прочитай файл протокол"), true);
  });

  test("returns true for 'полностью'", () => {
    assert.equal(hasContentDisplayIntent("покажи файл полностью"), true);
  });

  test("returns true for 'целиком'", () => {
    assert.equal(hasContentDisplayIntent("выведи файл целиком"), true);
  });

  test("returns true for 'содержание'", () => {
    assert.equal(hasContentDisplayIntent("покажи содержание файла"), true);
  });

  test("returns true for 'содержимое'", () => {
    assert.equal(hasContentDisplayIntent("выведи содержимое"), true);
  });

  test("returns true for 'весь текст'", () => {
    assert.equal(hasContentDisplayIntent("покажи весь текст файла"), true);
  });

  test("returns true for 'что внутри'", () => {
    assert.equal(hasContentDisplayIntent("что внутри файла?"), true);
  });

  test("returns true for 'что в нём'", () => {
    assert.equal(hasContentDisplayIntent("что в нём?"), true);
  });

  test("returns true for 'что в файле'", () => {
    assert.equal(hasContentDisplayIntent("что в файле?"), true);
  });

  // ─── English queries with content intent ───────────────────────────────

  test("returns true for 'display the content'", () => {
    assert.equal(hasContentDisplayIntent("display the content of the file"), true);
  });

  test("returns true for 'read the file'", () => {
    assert.equal(hasContentDisplayIntent("please read the file"), true);
  });

  test("returns true for 'show full content'", () => {
    assert.equal(hasContentDisplayIntent("show full content"), true);
  });

  test("returns true for 'show the entire text'", () => {
    assert.equal(hasContentDisplayIntent("show the entire text"), true);
  });

  test("returns true for 'entire content'", () => {
    assert.equal(hasContentDisplayIntent("display entire content"), true);
  });

  test("returns true for 'whole file'", () => {
    assert.equal(hasContentDisplayIntent("show the whole file"), true);
  });

  test("returns true for \"what's inside\"", () => {
    assert.equal(hasContentDisplayIntent("what's inside?"), true);
  });

  test("returns true for 'what is in'", () => {
    assert.equal(hasContentDisplayIntent("what is in the file?"), true);
  });

  // ─── Queries WITHOUT content intent ────────────────────────────────────

  test("returns false for simple filename listing 'найди файл протокол'", () => {
    assert.equal(hasContentDisplayIntent("найди файл протокол"), false);
  });

  test("returns false for 'найди все файлы с именем отчёт'", () => {
    assert.equal(hasContentDisplayIntent("найди все файлы с именем отчёт"), false);
  });

  test("returns false for 'find files named protocol'", () => {
    assert.equal(hasContentDisplayIntent("find files named protocol"), false);
  });

  test("returns false for 'list files with name invoice'", () => {
    assert.equal(hasContentDisplayIntent("list files with name invoice"), false);
  });

  test("returns false for empty string", () => {
    assert.equal(hasContentDisplayIntent(""), false);
  });
});