@chatman-media/kb 1.4.0 → 1.6.0

package/src/ingest.test.ts

@@ -0,0 +1,178 @@
+// Unit tests for the ingest pipeline (ingestFile / ingestText / ingestDirectory)
+// + the pure helpers (deriveTopicFromPath, stripNonContent). The KB store and
+// embedder are faked; ingestFile/ingestDirectory use real temp files on disk.
+
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { EmbeddingClient } from "@chatman-media/llm-router";
+import {
+  deriveTopicFromPath,
+  type IngestDeps,
+  ingestDirectory,
+  ingestFile,
+  ingestText,
+  stripNonContent,
+} from "./ingest.ts";
+import type { IKbStore } from "./types.ts";
+
+interface FakeStoreState {
+  docs: Map<string, { id: number; content_hash: string; chunkCount: number }>;
+  inserted: number;
+  deleted: number[];
+  nextId: number;
+}
+
+function fakeStore(state: FakeStoreState): IKbStore {
+  return {
+    search: async () => [],
+    hybridSearch: async () => [],
+    prioritySearch: async () => [],
+    getDocumentBySource: async (source: string) => {
+      const d = state.docs.get(source);
+      return d ? { id: d.id, content_hash: d.content_hash } : null;
+    },
+    countChunksForDocument: async (id: number) => {
+      for (const d of state.docs.values()) if (d.id === id) return d.chunkCount;
+      return 0;
+    },
+    deleteDocument: async (id: number) => {
+      state.deleted.push(id);
+      return true;
+    },
+    upsertDocument: async (input: { source: string; contentHash: string }) => {
+      const id = state.nextId++;
+      state.docs.set(input.source, { id, content_hash: input.contentHash, chunkCount: 0 });
+      return { id };
+    },
+    insertChunkWithEmbedding: async () => {
+      state.inserted++;
+    },
+  } as unknown as IKbStore;
+}
+
+function newState(): FakeStoreState {
+  return { docs: new Map(), inserted: 0, deleted: [], nextId: 1 };
+}
+
+const embedder: EmbeddingClient = {
+  embed: async (inputs: string[]) => inputs.map(() => [0.1, 0.2, 0.3]),
+  dim: 3,
+};
+
+const tmpDirs: string[] = [];
+function tmp(): string {
+  const d = mkdtempSync(join(tmpdir(), "kb-ingest-"));
+  tmpDirs.push(d);
+  return d;
+}
+afterEach(() => {
+  while (tmpDirs.length) rmSync(tmpDirs.pop() as string, { recursive: true, force: true });
+});
+
+describe("stripNonContent", () => {
+  it("снимает YAML-frontmatter", () => {
+    expect(stripNonContent("---\ntitle: x\n---\nBody here")).toBe("Body here\n");
+  });
+  it("снимает HTML-комментарии (в т.ч. вложенный остаток)", () => {
+    expect(stripNonContent("a<!-- c -->b")).toBe("ab\n");
+  });
+  it("схлопывает 3+ переводов строк", () => {
+    expect(stripNonContent("a\n\n\n\nb")).toBe("a\n\nb\n");
+  });
+});
+
+describe("deriveTopicFromPath", () => {
+  it("файл прямо в root → null", () => {
+    expect(deriveTopicFromPath("/r/a.md", "/r")).toBeNull();
+  });
+  it("первая поддиректория → topic", () => {
+    expect(deriveTopicFromPath("/r/china/jobs/a.md", "/r")).toBe("china");
+  });
+});
+
+describe("ingestText", () => {
+  it("создаёт документ и чанки, source=inline:<hash12>", async () => {
+    const state = newState();
+    const deps: IngestDeps = { kb: fakeStore(state), embedder };
+    const r = await ingestText({ title: "Doc", body: "some content body text" }, deps);
+    expect(r.created).toBe(true);
+    expect(r.source).toStartWith("inline:");
+    expect(r.chunks).toBeGreaterThan(0);
+    expect(state.inserted).toBe(r.chunks);
+  });
+
+  it("пустой title → 'untitled'; пустое тело → 0 чанков", async () => {
+    const state = newState();
+    const r = await ingestText({ title: "  ", body: "" }, { kb: fakeStore(state), embedder });
+    expect(r.chunks).toBe(0);
+    expect(state.inserted).toBe(0);
+  });
+
+  it("повторная загрузка идентичного контента → dedup (created:false)", async () => {
+    const state = newState();
+    const deps: IngestDeps = { kb: fakeStore(state), embedder };
+    const first = await ingestText({ title: "D", body: "stable text payload" }, deps);
+    // mark existing doc as having chunks so the dedup short-circuit fires
+    for (const d of state.docs.values()) d.chunkCount = first.chunks;
+    const second = await ingestText({ title: "D", body: "stable text payload" }, deps);
+    expect(second.created).toBe(false);
+    expect(second.documentId).toBe(first.documentId);
+  });
+
+  it("существующий док с другим hash → удаляется и пересоздаётся", async () => {
+    const state = newState();
+    const deps: IngestDeps = { kb: fakeStore(state), embedder, topic: "t" };
+    const first = await ingestText({ title: "D", body: "version one" }, deps);
+    for (const d of state.docs.values()) d.chunkCount = first.chunks;
+    // same source (hash of inline depends on body) — change body keeps a NEW source,
+    // so to force the delete path we reuse the same body but reset stored hash.
+    for (const d of state.docs.values()) d.content_hash = "STALE";
+    const second = await ingestText({ title: "D", body: "version one" }, deps);
+    expect(second.created).toBe(true);
+    expect(state.deleted.length).toBe(1);
+  });
+});
+
+describe("ingestFile", () => {
+  it("читает .md, стрипает frontmatter, индексирует чанки", async () => {
+    const dir = tmp();
+    const file = join(dir, "doc.md");
+    writeFileSync(file, "---\nx: 1\n---\nHello world content here.", "utf8");
+    const state = newState();
+    const r = await ingestFile(file, { kb: fakeStore(state), embedder });
+    expect(r.created).toBe(true);
+    expect(r.source).toBe(`file://${file}`);
+    expect(r.chunks).toBeGreaterThan(0);
+  });
+
+  it("source/title override", async () => {
+    const dir = tmp();
+    const file = join(dir, "tmpname.txt");
+    writeFileSync(file, "body text", "utf8");
+    const state = newState();
+    const r = await ingestFile(file, {
+      kb: fakeStore(state),
+      embedder,
+      source: "upload:abc",
+      title: "Nice Title",
+    });
+    expect(r.source).toBe("upload:abc");
+  });
+});
+
+describe("ingestDirectory", () => {
+  it("обходит дерево, пропускает неподдерживаемые расширения, выводит topic из подпапки", async () => {
+    const root = tmp();
+    mkdirSync(join(root, "china"));
+    writeFileSync(join(root, "china", "a.md"), "alpha content", "utf8");
+    writeFileSync(join(root, "b.txt"), "bravo content", "utf8");
+    writeFileSync(join(root, "skip.json"), "{}", "utf8");
+    const state = newState();
+    const summary = await ingestDirectory(root, { kb: fakeStore(state), embedder });
+    expect(summary.documents).toBe(2);
+    expect(summary.skipped).toBe(1);
+    expect(summary.chunks).toBeGreaterThan(0);
+  });
+});

package/src/prompt.test.ts

@@ -19,6 +19,154 @@ const baseStyle: Style = {
   model: { id: "x", temperature: 0.5, maxTokens: 100 },
 };
 
+describe("composeSystemPrompt — persona / voice / framework blocks", () => {
+  it("human persona: менеджер агентства + честное раскрытие бота (botDisclosure=true)", () => {
+    const p = composeSystemPrompt(
+      { ...baseStyle, persona: { name: "Аня", role: "human", company: "Acme" } },
+      "qualify",
+    );
+    expect(p).toContain("менеджер агентства Acme");
+    expect(p).toContain("ЧЕСТНО ответь, что ты ИИ-ассистент");
+    expect(p).toContain("ФРЕЙМВОРК");
+  });
+
+  it("human persona, botDisclosure=false → уклончивый ответ про бота", () => {
+    const s: Style = {
+      ...baseStyle,
+      guardrails: { ...baseStyle.guardrails, botDisclosureOnDirectQuestion: false },
+    };
+    const p = composeSystemPrompt(s, "qualify");
+    expect(p).toContain("отвечай уклончиво");
+  });
+
+  it("assistant persona: ИИ-ассистент", () => {
+    const p = composeSystemPrompt(
+      { ...baseStyle, persona: { name: "Бот", role: "assistant", company: "Acme" } },
+      "qualify",
+    );
+    expect(p).toContain("ИИ-ассистент агентства Acme");
+  });
+
+  it("persona.facts → блок личных фактов", () => {
+    const p = composeSystemPrompt(
+      { ...baseStyle, persona: { name: "Аня", role: "human", facts: { age: "25", empty: " " } } },
+      "qualify",
+    );
+    expect(p).toContain("ЛИЧНЫЕ ФАКТЫ");
+    expect(p).toContain("age: 25");
+    expect(p).not.toContain("empty");
+  });
+
+  it("voice.forbid → блок ЗАПРЕЩЕНО; язык en", () => {
+    const p = composeSystemPrompt(
+      { ...baseStyle, voice: { tone: "bold", language: "en", forbid: ["мат", "сленг"] } },
+      "qualify",
+    );
+    expect(p).toContain("Язык: английский");
+    expect(p).toContain("ЗАПРЕЩЕНО: мат; сленг");
+  });
+});
+
+describe("composeSystemPrompt — hooks / director hooks / skills", () => {
+  it("hooks → блок ХУКИ с лейблами", () => {
+    const p = composeSystemPrompt(
+      { ...baseStyle, hooks: [{ kind: "scarcity", text: "осталось 3 места" }] },
+      "qualify",
+    );
+    expect(p).toContain("ДЕФИЦИТ: осталось 3 места");
+  });
+
+  it("directorHooks → блок ХУКИ УБЕЖДЕНИЯ + triggerHint", () => {
+    const p = composeSystemPrompt(baseStyle, "qualify", null, {
+      directorHooks: [{ name: "FOMO", body: "дави на срочность", triggerHint: "колеблется" }],
+    });
+    expect(p).toContain("ХУКИ УБЕЖДЕНИЯ");
+    expect(p).toContain("FOMO");
+    expect(p).toContain("Когда: колеблется");
+  });
+
+  it("skills фильтруются по стадии", () => {
+    const p = composeSystemPrompt(baseStyle, "qualify", null, {
+      skills: [
+        { slug: "mirror", displayName: "Зеркало", promptFragment: "отражай", applicableStages: ["qualify"] },
+        { slug: "close", displayName: "Закрытие", promptFragment: "закрывай", applicableStages: ["close"] },
+        { slug: "always", displayName: "Всегда", promptFragment: "везде", applicableStages: [] },
+      ],
+    });
+    expect(p).toContain("ПРИЁМЫ");
+    expect(p).toContain("Зеркало");
+    expect(p).toContain("Всегда");
+    expect(p).not.toContain("Закрытие");
+  });
+});
+
+describe("composeSystemPrompt — support mode / grounding / few-shot", () => {
+  it("supportPhase=docs → блок поддержки, sales-блоки выкинуты", () => {
+    const s: Style = { ...baseStyle, hooks: [{ kind: "scarcity", text: "x" }] };
+    const p = composeSystemPrompt(s, "qualify", null, { supportPhase: "docs" });
+    expect(p).toContain("РЕЖИМ ПОДДЕРЖКИ");
+    expect(p).toContain("около 10 дней");
+    expect(p).not.toContain("ФРЕЙМВОРК");
+    expect(p).not.toContain("ДЕФИЦИТ");
+  });
+
+  it("supportPhase=submitted → текст про консульство", () => {
+    const p = composeSystemPrompt(baseStyle, "qualify", null, { supportPhase: "submitted" });
+    expect(p).toContain("подана в консульство");
+  });
+
+  it("groundingRequired + нет KB контекста → напоминание о grounding (human)", () => {
+    const s: Style = {
+      ...baseStyle,
+      persona: { name: "Аня", role: "human" },
+      stages: { qualify: { goal: "G", groundingRequired: true } },
+    };
+    const p = composeSystemPrompt(s, "qualify");
+    expect(p).toContain("GROUNDING");
+    expect(p).toContain("Никогда не выдумывай");
+  });
+
+  it("groundingRequired + есть KB контекст → KB CONTEXT присутствует", () => {
+    const s: Style = {
+      ...baseStyle,
+      stages: { qualify: { goal: "G", groundingRequired: true } },
+    };
+    const p = composeSystemPrompt(s, "qualify", "факт: зарплата 1500");
+    expect(p).toContain("KB CONTEXT");
+  });
+
+  it("few-shot включается по умолчанию и выключается флагом", () => {
+    const s: Style = {
+      ...baseStyle,
+      fewShot: [{ user: "сколько?", assistant: "уточню", stage: "qualify" }],
+    };
+    expect(composeSystemPrompt(s, "qualify")).toContain("ПРИМЕРЫ ДИАЛОГА");
+    expect(composeSystemPrompt(s, "qualify", null, { includeFewShot: false })).not.toContain(
+      "ПРИМЕРЫ ДИАЛОГА",
+    );
+  });
+
+  it("guardrails: noMinors + forbiddenTopics → жёсткие правила", () => {
+    const s: Style = {
+      ...baseStyle,
+      guardrails: {
+        noMinors: true,
+        botDisclosureOnDirectQuestion: true,
+        forbiddenTopics: ["политика"],
+      },
+    };
+    const p = composeSystemPrompt(s, "qualify");
+    expect(p).toContain("ЖЁСТКИЕ ПРАВИЛА");
+    expect(p).toContain("<18 лет");
+    expect(p).toContain("Запрещённые темы: политика");
+  });
+
+  it("стадия без конфига и без override → generic-блок", () => {
+    const p = composeSystemPrompt(baseStyle, "pitch");
+    expect(p).toContain("Специфических правил для этапа нет");
+  });
+});
+
 describe("composeSystemPrompt — stageOverride (Phase 2 C-2)", () => {
   it("без override → goal берётся из Style", () => {
     const p = composeSystemPrompt(baseStyle, "qualify");
@@ -42,3 +190,30 @@ describe("composeSystemPrompt — stageOverride (Phase 2 C-2)", () => {
     expect(p).toContain("CLOSE_GOAL");
   });
 });
+
+describe("composeSystemPrompt — requestContext (R4 multi-request)", () => {
+  it("requestContext → блок «ЗАПРОС ГОСТЯ» в промпте", () => {
+    const p = composeSystemPrompt(baseStyle, "qualify", null, {
+      requestContext: "гость сейчас ведёт запрос «Трансфер».",
+    });
+    expect(p).toContain("ЗАПРОС ГОСТЯ:");
+    expect(p).toContain("«Трансфер»");
+  });
+
+  it("без requestContext → блока нет", () => {
+    const p = composeSystemPrompt(baseStyle, "qualify");
+    expect(p).not.toContain("ЗАПРОС ГОСТЯ:");
+  });
+});
+
+describe("composeSystemPrompt — awaitingOperator (R5)", () => {
+  it("awaitingOperator → блок «ОЖИДАНИЕ ОПЕРАТОРА»", () => {
+    const p = composeSystemPrompt(baseStyle, "close", null, { awaitingOperator: true });
+    expect(p).toContain("ОЖИДАНИЕ ОПЕРАТОРА");
+  });
+
+  it("без флага → блока нет", () => {
+    const p = composeSystemPrompt(baseStyle, "close");
+    expect(p).not.toContain("ОЖИДАНИЕ ОПЕРАТОРА");
+  });
+});

package/src/prompt.ts

@@ -134,6 +134,17 @@ export function composeSystemPrompt(
         : "")
     : `ТЕКУЩИЙ ЭТАП: ${stage}. (Специфических правил для этапа нет — используй общий стиль.)`;
 
+  // Динамический контекст текущего запроса гостя (multi-request): тип запроса +
+  // сколько открыто — помогает боту не путать параллельные заявки.
+  const requestBlock = options.requestContext
+    ? `ЗАПРОС ГОСТЯ: ${options.requestContext}`
+    : "";
+
+  // Лид ждёт оператора (awaiting_operator): бот держит, не выдумывает цену/условия.
+  const operatorBlock = options.awaitingOperator
+    ? `ОЖИДАНИЕ ОПЕРАТОРА: на этой стадии условия/цену/решение готовит коллега-человек. НЕ выдумывай числа и детали. Скажи гостю коротко, что уточняешь и вернёшься с ответом — и жди, не дави и не закрывай сделку.`
+    : "";
+
   const minorRule = guardrails.noMinors ? "- Если prospect <18 лет — вежливо заверши диалог." : "";
   const topicsRule = guardrails.forbiddenTopics.length
     ? `- Запрещённые темы: ${guardrails.forbiddenTopics.join(", ")}.`
@@ -182,6 +193,8 @@ export function composeSystemPrompt(
     support ? "" : directorHooksBlock,
     support ? "" : skillsBlock,
     support || stageBlock,
+    operatorBlock,
+    requestBlock,
     summaryBlock,
     userFactsBlock,
     needsGroundingReminder ? kbGroundingReminder(persona.role) : "",

package/src/styles.ts

@@ -141,4 +141,15 @@ export interface ComposeOptions {
    * block. Lets AI-built funnels carry per-stage instructions.
    */
   stageOverride?: { goal: string; guidance?: string };
+  /**
+   * Динамический контекст текущего запроса гостя (multi-request / concierge):
+   * какой тип запроса ведётся + сколько открыто. Инжектится блоком «ЗАПРОС
+   * ГОСТЯ». null/absent для линейных вертикалей.
+   */
+  requestContext?: string;
+  /**
+   * Лид стоит на стадии awaiting_operator (R5): цену/условия даёт человек-оператор.
+   * Бот придерживает гостя и не выдумывает детали. Блок «ОЖИДАНИЕ ОПЕРАТОРА».
+   */
+  awaitingOperator?: boolean;
 }

package/src/system-prompt.test.ts

@@ -0,0 +1,81 @@
+// Unit tests for the legacy (non-style) system-prompt builder and its block
+// renderers. Pure functions — no fakes needed.
+
+import { describe, expect, it } from "bun:test";
+import {
+  buildSystemPrompt,
+  DEFAULT_PERSONA,
+  legacyRagSamplingTemperature,
+  renderSummaryBlock,
+  renderUserFactsBlock,
+} from "./system-prompt.ts";
+
+describe("legacyRagSamplingTemperature", () => {
+  it("human → 0.55, assistant → 0.38", () => {
+    expect(legacyRagSamplingTemperature({ name: "x", role: "human" })).toBe(0.55);
+    expect(legacyRagSamplingTemperature({ name: "x", role: "assistant" })).toBe(0.38);
+  });
+  it("override имеет приоритет", () => {
+    expect(legacyRagSamplingTemperature(DEFAULT_PERSONA, 0.9)).toBe(0.9);
+  });
+});
+
+describe("renderSummaryBlock", () => {
+  it("пусто/whitespace → ''", () => {
+    expect(renderSummaryBlock()).toBe("");
+    expect(renderSummaryBlock("   ")).toBe("");
+  });
+  it("с текстом → блок «ИЗ РАННЕЙ ПЕРЕПИСКИ»", () => {
+    expect(renderSummaryBlock("обсудили визу")).toContain("ИЗ РАННЕЙ ПЕРЕПИСКИ");
+  });
+});
+
+describe("renderUserFactsBlock", () => {
+  it("undefined / только пустые значения → ''", () => {
+    expect(renderUserFactsBlock()).toBe("");
+    expect(renderUserFactsBlock({ city: "  " })).toBe("");
+  });
+  it("факты → bullet-список", () => {
+    const b = renderUserFactsBlock({ city: "Москва", age: "25" });
+    expect(b).toContain("- city: Москва");
+    expect(b).toContain("- age: 25");
+  });
+});
+
+describe("buildSystemPrompt", () => {
+  it("human persona: НИКОГДА не говори что ты ИИ + компания", () => {
+    const p = buildSystemPrompt({ name: "Аня", role: "human", company: "Acme" }, "CTX");
+    expect(p).toContain("Аня");
+    expect(p).toContain("Acme");
+    expect(p).toContain("НИКОГДА");
+    expect(p).toContain("ЖИВАЯ РЕЧЬ");
+    expect(p).toContain("CONTEXT:\nCTX");
+  });
+
+  it("assistant persona: ИИ-ассистент, без блока живой речи", () => {
+    const p = buildSystemPrompt({ name: "Бот", role: "assistant" }, "CTX");
+    expect(p).toContain("ИИ-ассистент");
+    expect(p).not.toContain("ЖИВАЯ РЕЧЬ");
+  });
+
+  it("persona.facts → блок ЛИЧНЫЕ ФАКТЫ (пустые отброшены)", () => {
+    const p = buildSystemPrompt(
+      { name: "Аня", role: "human", facts: { city: "Сочи", empty: "  " } },
+      "CTX",
+    );
+    expect(p).toContain("ЛИЧНЫЕ ФАКТЫ");
+    expect(p).toContain("city: Сочи");
+    expect(p).not.toContain("empty");
+  });
+
+  it("userFacts + summary секции добавляются", () => {
+    const p = buildSystemPrompt(
+      { name: "x", role: "assistant" },
+      "CTX",
+      { age: "30" },
+      "ранее обсудили",
+    );
+    expect(p).toContain("ЗНАЕМ О КАНДИДАТЕ");
+    expect(p).toContain("ИЗ РАННЕЙ ПЕРЕПИСКИ");
+  });
+});