efarmz-slackbot-data 1.0.0

package/src/infrastructure/llm/mappers/AnthropicMessageMapper.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect } from "vitest";
+import type Anthropic from "@anthropic-ai/sdk";
+import AnthropicMessageMapper from "./AnthropicMessageMapper.js";
+import type { LLMRequest } from "@/domain/ports/LLMProvider.js";
+
+describe(`AnthropicMessageMapper`, () => {
+  describe(`toSDK`, () => {
+    it(`should convert user message to SDK format`, () => {
+      const messages: LLMRequest["messages"] = [
+        { role: `user`, content: `What is the data?` },
+      ];
+
+      const result = AnthropicMessageMapper.toSDK(messages);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        role: `user`,
+        content: `What is the data?`,
+      });
+    });
+
+    it(`should convert multiple messages preserving order`, () => {
+      const messages: LLMRequest["messages"] = [
+        { role: `user`, content: `Question 1` },
+        { role: `assistant`, content: `Answer 1` },
+        { role: `user`, content: `Question 2` },
+      ];
+
+      const result = AnthropicMessageMapper.toSDK(messages);
+
+      expect(result).toHaveLength(3);
+      expect(result[0]?.content).toBe(`Question 1`);
+      expect(result[1]?.content).toBe(`Answer 1`);
+      expect(result[2]?.content).toBe(`Question 2`);
+    });
+  });
+
+  describe(`fromSDK`, () => {
+    it(`should extract text content from response`, () => {
+      const response: Anthropic.Message = {
+        id: `msg_123`,
+        type: `message`,
+        role: `assistant`,
+        content: [
+          { type: `text`, text: `Here is the answer` },
+        ],
+        model: `claude-3-5-sonnet-20241022`,
+        stop_reason: `end_turn`,
+        stop_sequence: null,
+        usage: { input_tokens: 10, output_tokens: 20 },
+      };
+
+      const result = AnthropicMessageMapper.fromSDK(response);
+
+      expect(result.content).toBe(`Here is the answer`);
+    });
+
+    it(`should extract tool uses from response`, () => {
+      const response: Anthropic.Message = {
+        id: `msg_123`,
+        type: `message`,
+        role: `assistant`,
+        content: [
+          {
+            type: `tool_use`,
+            id: `tool_123`,
+            name: `run_sql`,
+            input: { sql: `SELECT * FROM users` },
+          } as unknown as Anthropic.ToolUseBlock,
+        ],
+        model: `claude-3-5-sonnet-20241022`,
+        stop_reason: `tool_use`,
+        stop_sequence: null,
+        usage: { input_tokens: 10, output_tokens: 20 },
+      };
+
+      const result = AnthropicMessageMapper.fromSDK(response);
+
+      expect(result.toolUses).toHaveLength(1);
+      expect(result.toolUses[0]).toEqual({
+        id: `tool_123`,
+        name: `run_sql`,
+        input: { sql: `SELECT * FROM users` },
+      });
+    });
+
+    it(`should set stop reason correctly`, () => {
+      const response: Anthropic.Message = {
+        id: `msg_123`,
+        type: `message`,
+        role: `assistant`,
+        content: [{ type: `text`, text: `Done` }],
+        model: `claude-3-5-sonnet-20241022`,
+        stop_reason: `end_turn`,
+        stop_sequence: null,
+        usage: { input_tokens: 10, output_tokens: 20 },
+      };
+
+      const result = AnthropicMessageMapper.fromSDK(response);
+
+      expect(result.stopReason).toBe(`end_turn`);
+    });
+
+    it(`should extract token counts`, () => {
+      const response: Anthropic.Message = {
+        id: `msg_123`,
+        type: `message`,
+        role: `assistant`,
+        content: [{ type: `text`, text: `Response` }],
+        model: `claude-3-5-sonnet-20241022`,
+        stop_reason: `end_turn`,
+        stop_sequence: null,
+        usage: { input_tokens: 100, output_tokens: 50 },
+      };
+
+      const result = AnthropicMessageMapper.fromSDK(response);
+
+      expect(result.inputTokens).toBe(100);
+      expect(result.outputTokens).toBe(50);
+    });
+
+    it(`should handle mixed text and tool use content`, () => {
+      const response: Anthropic.Message = {
+        id: `msg_123`,
+        type: `message`,
+        role: `assistant`,
+        content: [
+          { type: `text`, text: `Let me query the data:` },
+          {
+            type: `tool_use`,
+            id: `tool_456`,
+            name: `run_sql`,
+            input: { sql: `SELECT count(*) FROM data` },
+          } as unknown as Anthropic.ToolUseBlock,
+        ],
+        model: `claude-3-5-sonnet-20241022`,
+        stop_reason: `tool_use`,
+        stop_sequence: null,
+        usage: { input_tokens: 50, output_tokens: 30 },
+      };
+
+      const result = AnthropicMessageMapper.fromSDK(response);
+
+      expect(result.content).toBe(`Let me query the data:`);
+      expect(result.toolUses).toHaveLength(1);
+      expect(result.toolUses[0]?.name).toBe(`run_sql`);
+    });
+
+    it(`should return empty content when no text block present`, () => {
+      const response: Anthropic.Message = {
+        id: `msg_123`,
+        type: `message`,
+        role: `assistant`,
+        content: [
+          {
+            type: `tool_use`,
+            id: `tool_789`,
+            name: `run_sql`,
+            input: {},
+          } as unknown as Anthropic.ToolUseBlock,
+        ],
+        model: `claude-3-5-sonnet-20241022`,
+        stop_reason: `tool_use`,
+        stop_sequence: null,
+        usage: { input_tokens: 10, output_tokens: 20 },
+      };
+
+      const result = AnthropicMessageMapper.fromSDK(response);
+
+      expect(result.content).toBe(``);
+    });
+  });
+});

package/src/infrastructure/llm/mappers/AnthropicMessageMapper.ts

@@ -0,0 +1,34 @@
+import type Anthropic from "@anthropic-ai/sdk";
+import type {
+  LLMRequest,
+  LLMResponse,
+} from "@/domain/ports/LLMProvider.js";
+
+function toSDK(messages: LLMRequest["messages"]): Anthropic.MessageParam[] {
+  return messages.map((m) => ({
+    role: m.role,
+    content: m.content,
+  }));
+}
+
+function fromSDK(response: Anthropic.Message): LLMResponse {
+  const textBlock = response.content.find((c) => c.type === `text`);
+  const toolBlocks = response.content.filter((c) => c.type === `tool_use`);
+
+  const content = textBlock ? textBlock.text : ``;
+  const toolUses = toolBlocks.map((t) => ({
+    id: t.id,
+    name: t.name,
+    input: (t.input ?? {}) as Record<string, unknown>,
+  }));
+
+  return {
+    content,
+    toolUses,
+    stopReason: response.stop_reason as LLMResponse["stopReason"],
+    inputTokens: response.usage.input_tokens,
+    outputTokens: response.usage.output_tokens,
+  };
+}
+
+export default { toSDK, fromSDK };

package/src/infrastructure/llm/prompts/SystemPromptBuilder.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from "vitest";
+import SystemPromptBuilder from "./SystemPromptBuilder.js";
+
+describe(`SystemPromptBuilder`, () => {
+  it(`should build system prompt with two blocks`, () => {
+    const schemaDoc = `Database schema documentation`;
+    const result = SystemPromptBuilder.build(schemaDoc);
+
+    expect(result).toHaveLength(2);
+  });
+
+  it(`should have header as first block without cache control`, () => {
+    const schemaDoc = `Database schema documentation`;
+    const result = SystemPromptBuilder.build(schemaDoc);
+
+    const firstBlock = result[0];
+    expect(firstBlock?.type).toBe(`text`);
+    expect(firstBlock?.text).toContain(`data analyst assistant for efarmz`);
+    expect(firstBlock?.cache_control).toBeUndefined();
+  });
+
+  it(`should have schema as second block with ephemeral cache control`, () => {
+    const schemaDoc = `Database schema documentation`;
+    const result = SystemPromptBuilder.build(schemaDoc);
+
+    const secondBlock = result[1];
+    expect(secondBlock?.type).toBe(`text`);
+    expect(secondBlock?.text).toBe(schemaDoc);
+    expect(secondBlock?.cache_control).toEqual({ type: `ephemeral` });
+  });
+
+  it(`should include instructions in header`, () => {
+    const schemaDoc = `test schema`;
+    const result = SystemPromptBuilder.build(schemaDoc);
+
+    const headerText = result[0]?.text;
+    expect(headerText).toContain(`run_sql tool`);
+    expect(headerText).toContain(`SELECT`);
+    expect(headerText).toContain(`French`);
+  });
+});

package/src/infrastructure/llm/prompts/SystemPromptBuilder.ts

@@ -0,0 +1,31 @@
+const SYSTEM_PROMPT_HEADER = `You are a data analyst assistant for efarmz, responding in Slack.
+You answer questions by querying PostgreSQL databases using the run_sql tool.
+
+Rules:
+- ALWAYS use the run_sql tool to query data before answering
+- Only SELECT queries are allowed
+- Respond in French with natural, conversational language
+- Use Slack mrkdwn formatting: *bold* (single asterisk), _italic_, \`code\`
+- Use bullet points with • for lists
+- Use relevant emojis (📊 for data, 📦 for orders, 👥 for customers, 📅 for dates, etc.)
+- For a single value, write a full sentence: "Il y a eu *494* commandes cette semaine."
+- For multiple rows, write a short intro then list results with •
+- Format numbers with thousands separators and appropriate units
+- Keep responses concise and readable`;
+
+function build(schemaDoc: string): Array<{
+  type: string;
+  text: string;
+  cache_control?: { type: string };
+}> {
+  return [
+    { type: `text`, text: SYSTEM_PROMPT_HEADER },
+    {
+      type: `text`,
+      text: schemaDoc,
+      cache_control: { type: `ephemeral` },
+    },
+  ];
+}
+
+export default { build };

package/src/infrastructure/llm/prompts/ToolDefinitions.ts

@@ -0,0 +1,7 @@
+import RunSqlTool from "@/application/agent/tools/RunSqlTool.js";
+
+const ToolDefinitions = {
+  run_sql: RunSqlTool.definition,
+};
+
+export default ToolDefinitions;

package/src/infrastructure/logging/PinoLogger.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi } from "vitest";
+import PinoLogger from "./PinoLogger.js";
+
+describe(`PinoLogger`, () => {
+  it(`should instantiate with default log level (info)`, () => {
+    const logger = new PinoLogger();
+    expect(logger).toBeDefined();
+  });
+
+  it(`should instantiate with custom log level (debug)`, () => {
+    const logger = new PinoLogger(`debug`);
+    expect(logger).toBeDefined();
+  });
+
+  it(`should instantiate with custom log level (warn)`, () => {
+    const logger = new PinoLogger(`warn`);
+    expect(logger).toBeDefined();
+  });
+
+  it(`should call debug method without throwing`, () => {
+    const logger = new PinoLogger();
+    expect(() => logger.debug(`test debug`)).not.toThrow();
+  });
+
+  it(`should call debug method with meta without throwing`, () => {
+    const logger = new PinoLogger();
+    expect(() => logger.debug(`test debug`, { key: `value` })).not.toThrow();
+  });
+
+  it(`should call info method without throwing`, () => {
+    const logger = new PinoLogger();
+    expect(() => logger.info(`test info`)).not.toThrow();
+  });
+
+  it(`should call info method with meta without throwing`, () => {
+    const logger = new PinoLogger();
+    expect(() => logger.info(`test info`, { key: `value` })).not.toThrow();
+  });
+
+  it(`should call warn method without throwing`, () => {
+    const logger = new PinoLogger();
+    expect(() => logger.warn(`test warn`)).not.toThrow();
+  });
+
+  it(`should call warn method with meta without throwing`, () => {
+    const logger = new PinoLogger();
+    expect(() => logger.warn(`test warn`, { key: `value` })).not.toThrow();
+  });
+
+  it(`should call error method without throwing`, () => {
+    const logger = new PinoLogger();
+    expect(() => logger.error(`test error`)).not.toThrow();
+  });
+
+  it(`should call error method with meta without throwing`, () => {
+    const logger = new PinoLogger();
+    expect(() => logger.error(`test error`, { key: `value` })).not.toThrow();
+  });
+});

package/src/infrastructure/logging/PinoLogger.ts

@@ -0,0 +1,28 @@
+import pino from "pino";
+import type Logger from "@/domain/ports/Logger.js";
+
+class PinoLogger implements Logger {
+  private readonly logger: pino.Logger;
+
+  constructor(level: string = `info`) {
+    this.logger = pino({ level });
+  }
+
+  debug(msg: string, meta?: object): void {
+    this.logger.debug(meta ?? {}, msg);
+  }
+
+  info(msg: string, meta?: object): void {
+    this.logger.info(meta ?? {}, msg);
+  }
+
+  warn(msg: string, meta?: object): void {
+    this.logger.warn(meta ?? {}, msg);
+  }
+
+  error(msg: string, meta?: object): void {
+    this.logger.error(meta ?? {}, msg);
+  }
+}
+
+export default PinoLogger;

package/src/infrastructure/logging/index.ts

@@ -0,0 +1 @@
+export { default as PinoLogger } from "./PinoLogger.js";