efarmz-slackbot-data 1.0.0

package/src/application/usecases/AnswerQuestion.test.ts

@@ -0,0 +1,362 @@
+import { describe, it, expect, vi } from "vitest";
+import AnswerQuestion from "../usecases/AnswerQuestion.js";
+import type ConversationRepository from "@/domain/ports/ConversationRepository.js";
+import type SlackMessenger from "@/domain/ports/SlackMessenger.js";
+import type AdminLogger from "@/domain/ports/AdminLogger.js";
+import type { AdminLogEntry } from "@/domain/ports/AdminLogger.js";
+import type { QueryResult } from "@/domain/value-objects/QueryResult.js";
+import type RenderedResponse from "../formatting/RenderedResponse.js";
+import Conversation from "@/domain/entities/Conversation.js";
+import ThreadId from "@/domain/value-objects/ThreadId.js";
+import Question from "@/domain/value-objects/Question.js";
+import type AgentRunResult from "../agent/AgentRunResult.js";
+
+class FakeConversationRepository implements ConversationRepository {
+  private savedConversation: Conversation | null = null;
+  private conversationToReturn: Conversation | null = null;
+
+  setSavedConversation(conversation: Conversation | null): this {
+    this.conversationToReturn = conversation;
+    return this;
+  }
+
+  async get(): Promise<Conversation | null> {
+    return this.conversationToReturn;
+  }
+
+  async save(conversation: Conversation): Promise<void> {
+    this.savedConversation = conversation;
+  }
+
+  getSavedConversation(): Conversation | null {
+    return this.savedConversation;
+  }
+
+  async purge(): Promise<void> {
+    // no-op
+  }
+}
+
+class FakeAgentLoop {
+  private resultToReturn: AgentRunResult | null = null;
+
+  setResult(result: AgentRunResult): this {
+    this.resultToReturn = result;
+    return this;
+  }
+
+  async run(): Promise<AgentRunResult> {
+    if (!this.resultToReturn) {
+      throw new Error(`No result configured for FakeAgentLoop`);
+    }
+    return this.resultToReturn;
+  }
+}
+
+class FakeResponseRenderer {
+  private renderedResponse: RenderedResponse | null = null;
+
+  setResponse(response: RenderedResponse): this {
+    this.renderedResponse = response;
+    return this;
+  }
+
+  render(): RenderedResponse {
+    if (!this.renderedResponse) {
+      throw new Error(`No response configured for FakeResponseRenderer`);
+    }
+    return this.renderedResponse;
+  }
+}
+
+class FakeSlackMessenger implements SlackMessenger {
+  private lastPostText: string | null = null;
+  private lastPostCsvBuffer: Buffer | null = null;
+  private lastPostCsvFilename: string | null = null;
+
+  async post(_threadId: never, text: string): Promise<void> {
+    this.lastPostText = text;
+  }
+
+  async postCsv(_threadId: never, text: string, csvBuffer: Buffer, filename: string): Promise<void> {
+    this.lastPostText = text;
+    this.lastPostCsvBuffer = csvBuffer;
+    this.lastPostCsvFilename = filename;
+  }
+
+  getLastPostText(): string | null {
+    return this.lastPostText;
+  }
+
+  getLastPostCsvBuffer(): Buffer | null {
+    return this.lastPostCsvBuffer;
+  }
+
+  getLastPostCsvFilename(): string | null {
+    return this.lastPostCsvFilename;
+  }
+}
+
+class FakeAdminLogger implements AdminLogger {
+  private loggedEntry: AdminLogEntry | null = null;
+
+  async logQuery(entry: AdminLogEntry): Promise<void> {
+    this.loggedEntry = entry;
+  }
+
+  getLoggedEntry(): AdminLogEntry | null {
+    return this.loggedEntry;
+  }
+}
+
+describe(`AnswerQuestion`, () => {
+  it(`should orchestrate complete flow without CSV`, async () => {
+    const threadId = ThreadId.create(`C12345`, `1234567890.123456`);
+    const question = Question.create(`How many users?`);
+    const userId = `U12345`;
+
+    const queryResult: QueryResult = {
+      columns: [`count`],
+      rows: [{ count: 42 }],
+      rowCount: 1,
+    };
+
+    const agentResult: AgentRunResult = {
+      finalText: `There are 42 users`,
+      executedSqls: [`SELECT COUNT(*) as count FROM users`],
+      queryResult,
+      inputTokens: 100,
+      outputTokens: 50,
+    };
+
+    const conversationRepo = new FakeConversationRepository();
+    const agentLoop = new FakeAgentLoop().setResult(agentResult);
+    const responseRenderer = new FakeResponseRenderer().setResponse({
+      text: `**42**`,
+      csvBuffer: undefined,
+      csvFilename: undefined,
+    });
+    const slackMessenger = new FakeSlackMessenger();
+    const adminLogger = new FakeAdminLogger();
+
+    const useCase = new AnswerQuestion(
+      conversationRepo,
+      agentLoop as any,
+      responseRenderer as any,
+      slackMessenger,
+      adminLogger,
+    );
+
+    await useCase.execute(question, threadId, userId);
+
+    // Verify conversation was saved with new messages
+    const savedConversation = conversationRepo.getSavedConversation();
+    expect(savedConversation).not.toBeNull();
+    expect(savedConversation!.messages.length).toBe(2);
+    expect(savedConversation!.messages[0]!.role).toBe(`user`);
+    expect(savedConversation!.messages[0]!.content).toBe(`How many users?`);
+    expect(savedConversation!.messages[1]!.role).toBe(`assistant`);
+    expect(savedConversation!.messages[1]!.content).toBe(`There are 42 users`);
+
+    // Verify message was posted without CSV
+    expect(slackMessenger.getLastPostText()).toBe(`**42**`);
+    expect(slackMessenger.getLastPostCsvBuffer()).toBeNull();
+    expect(slackMessenger.getLastPostCsvFilename()).toBeNull();
+
+    // Verify admin logging
+    const logEntry = adminLogger.getLoggedEntry();
+    expect(logEntry).not.toBeNull();
+    expect(logEntry!.userId).toBe(userId);
+    expect(logEntry!.question).toBe(`How many users?`);
+    expect(logEntry!.sqls).toEqual([`SELECT COUNT(*) as count FROM users`]);
+    expect(logEntry!.rowCount).toBe(1);
+    expect(logEntry!.inputTokens).toBe(100);
+    expect(logEntry!.outputTokens).toBe(50);
+    expect(logEntry!.durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it(`should post CSV when query result exceeds threshold`, async () => {
+    const threadId = ThreadId.create(`C12345`, `1234567890.123456`);
+    const question = Question.create(`Get all users`);
+    const userId = `U12345`;
+
+    const rows = Array.from({ length: 20 }, (_, i) => ({
+      id: i + 1,
+      name: `user${i + 1}`,
+    }));
+    const queryResult: QueryResult = {
+      columns: [`id`, `name`],
+      rows,
+      rowCount: 20,
+    };
+
+    const agentResult: AgentRunResult = {
+      finalText: `Found 20 users`,
+      executedSqls: [`SELECT id, name FROM users LIMIT 100`],
+      queryResult,
+      inputTokens: 150,
+      outputTokens: 75,
+    };
+
+    const csvBuffer = Buffer.from(`id,name\n1,user1\n2,user2`);
+
+    const conversationRepo = new FakeConversationRepository();
+    const agentLoop = new FakeAgentLoop().setResult(agentResult);
+    const responseRenderer = new FakeResponseRenderer().setResponse({
+      text: `Table: ... (truncated)`,
+      csvBuffer,
+      csvFilename: `result_1234567890.csv`,
+    });
+    const slackMessenger = new FakeSlackMessenger();
+    const adminLogger = new FakeAdminLogger();
+
+    const useCase = new AnswerQuestion(
+      conversationRepo,
+      agentLoop as any,
+      responseRenderer as any,
+      slackMessenger,
+      adminLogger,
+    );
+
+    await useCase.execute(question, threadId, userId);
+
+    // Verify CSV was posted
+    expect(slackMessenger.getLastPostText()).toBe(`Table: ... (truncated)`);
+    expect(slackMessenger.getLastPostCsvBuffer()).toEqual(csvBuffer);
+    expect(slackMessenger.getLastPostCsvFilename()).toBe(`result_1234567890.csv`);
+  });
+
+  it(`should skip conversation history when --no-context flag is set`, async () => {
+    const threadId = ThreadId.create(`C12345`, `1234567890.123456`);
+    const question = Question.create(`Answer this --no-context`);
+    const userId = `U12345`;
+
+    expect(question.flags.noContext).toBe(true);
+
+    const agentResult: AgentRunResult = {
+      finalText: `Direct answer`,
+      executedSqls: [],
+      queryResult: null,
+      inputTokens: 50,
+      outputTokens: 25,
+    };
+
+    const conversationRepo = new FakeConversationRepository();
+    // This mock should NOT be called when noContext is true
+    const getspy = vi.spyOn(conversationRepo, `get`);
+
+    const agentLoop = new FakeAgentLoop().setResult(agentResult);
+    const responseRenderer = new FakeResponseRenderer().setResponse({
+      text: `Direct answer`,
+      csvBuffer: undefined,
+      csvFilename: undefined,
+    });
+    const slackMessenger = new FakeSlackMessenger();
+    const adminLogger = new FakeAdminLogger();
+
+    const useCase = new AnswerQuestion(
+      conversationRepo,
+      agentLoop as any,
+      responseRenderer as any,
+      slackMessenger,
+      adminLogger,
+    );
+
+    await useCase.execute(question, threadId, userId);
+
+    // Verify get was NOT called
+    expect(getspy).not.toHaveBeenCalled();
+
+    // Verify conversation was created from scratch (new one)
+    const savedConversation = conversationRepo.getSavedConversation();
+    expect(savedConversation).not.toBeNull();
+    expect(savedConversation!.messages.length).toBe(2);
+  });
+
+  it(`should include existing conversation messages when noContext is false`, async () => {
+    const threadId = ThreadId.create(`C12345`, `1234567890.123456`);
+    const question = Question.create(`Follow-up question`);
+    const userId = `U12345`;
+
+    expect(question.flags.noContext).toBe(false);
+
+    const existingConversation = Conversation.create(threadId)
+      .append({ role: `user`, content: `First question`, timestamp: new Date() })
+      .append({ role: `assistant`, content: `First answer`, timestamp: new Date() });
+
+    const agentResult: AgentRunResult = {
+      finalText: `Follow-up answer`,
+      executedSqls: [`SELECT ...`],
+      queryResult: null,
+      inputTokens: 100,
+      outputTokens: 50,
+    };
+
+    const conversationRepo = new FakeConversationRepository().setSavedConversation(existingConversation);
+    const agentLoop = new FakeAgentLoop().setResult(agentResult);
+    const responseRenderer = new FakeResponseRenderer().setResponse({
+      text: `Follow-up answer`,
+      csvBuffer: undefined,
+      csvFilename: undefined,
+    });
+    const slackMessenger = new FakeSlackMessenger();
+    const adminLogger = new FakeAdminLogger();
+
+    const useCase = new AnswerQuestion(
+      conversationRepo,
+      agentLoop as any,
+      responseRenderer as any,
+      slackMessenger,
+      adminLogger,
+    );
+
+    await useCase.execute(question, threadId, userId);
+
+    // Verify conversation now has 4 messages (2 existing + 2 new)
+    const savedConversation = conversationRepo.getSavedConversation();
+    expect(savedConversation).not.toBeNull();
+    expect(savedConversation!.messages.length).toBe(4);
+    expect(savedConversation!.messages[0]!.content).toBe(`First question`);
+    expect(savedConversation!.messages[1]!.content).toBe(`First answer`);
+    expect(savedConversation!.messages[2]!.content).toBe(`Follow-up question`);
+    expect(savedConversation!.messages[3]!.content).toBe(`Follow-up answer`);
+  });
+
+  it(`should log query with null queryResult when no SQL was executed`, async () => {
+    const threadId = ThreadId.create(`C12345`, `1234567890.123456`);
+    const question = Question.create(`What is the weather?`);
+    const userId = `U12345`;
+
+    const agentResult: AgentRunResult = {
+      finalText: `No SQL needed for this`,
+      executedSqls: [],
+      queryResult: null,
+      inputTokens: 100,
+      outputTokens: 50,
+    };
+
+    const conversationRepo = new FakeConversationRepository();
+    const agentLoop = new FakeAgentLoop().setResult(agentResult);
+    const responseRenderer = new FakeResponseRenderer().setResponse({
+      text: `No SQL needed for this`,
+      csvBuffer: undefined,
+      csvFilename: undefined,
+    });
+    const slackMessenger = new FakeSlackMessenger();
+    const adminLogger = new FakeAdminLogger();
+
+    const useCase = new AnswerQuestion(
+      conversationRepo,
+      agentLoop as any,
+      responseRenderer as any,
+      slackMessenger,
+      adminLogger,
+    );
+
+    await useCase.execute(question, threadId, userId);
+
+    const logEntry = adminLogger.getLoggedEntry();
+    expect(logEntry!.rowCount).toBe(0);
+    expect(logEntry!.sqls).toEqual([]);
+  });
+});

package/src/application/usecases/AnswerQuestion.ts

@@ -0,0 +1,69 @@
+import type ConversationRepository from "@/domain/ports/ConversationRepository.js";
+import type SlackMessenger from "@/domain/ports/SlackMessenger.js";
+import type AdminLogger from "@/domain/ports/AdminLogger.js";
+import type Question from "@/domain/value-objects/Question.js";
+import type ThreadId from "@/domain/value-objects/ThreadId.js";
+import Conversation from "@/domain/entities/Conversation.js";
+import ConversationMessage from "@/domain/entities/ConversationMessage.js";
+import type AgentLoop from "../agent/AgentLoop.js";
+import type ResponseRenderer from "../formatting/ResponseRenderer.js";
+
+class AnswerQuestion {
+  constructor(
+    private readonly conversationRepository: ConversationRepository,
+    private readonly agentLoop: AgentLoop,
+    private readonly responseRenderer: ResponseRenderer,
+    private readonly slackMessenger: SlackMessenger,
+    private readonly adminLogger: AdminLogger,
+  ) {}
+
+  async execute(question: Question, threadId: ThreadId, userId: string): Promise<void> {
+    const startTime = Date.now();
+
+    // 1. Charger conversation (sauf si --no-context)
+    let conversation: Conversation | null = null;
+    if (!question.flags.noContext) {
+      conversation = await this.conversationRepository.get(threadId);
+    }
+
+    // 2. Exécuter la boucle agentique
+    const agentResult = await this.agentLoop.run({
+      conversation,
+      question,
+    });
+
+    // 3. Sauvegarder la conversation mise à jour
+    const updatedConversation = (conversation ?? Conversation.create(threadId))
+      .append(ConversationMessage.create(`user`, question.text))
+      .append(ConversationMessage.create(`assistant`, agentResult.finalText));
+    await this.conversationRepository.save(updatedConversation);
+
+    // 4. Formatter la réponse
+    const rendered = this.responseRenderer.render({
+      finalText: agentResult.finalText,
+      queryResult: agentResult.queryResult,
+      executedSqls: agentResult.executedSqls,
+      flags: question.flags,
+    });
+
+    // 5. Poster sur Slack
+    if (rendered.csvBuffer && rendered.csvFilename) {
+      await this.slackMessenger.postCsv(threadId, rendered.text, rendered.csvBuffer, rendered.csvFilename);
+    } else {
+      await this.slackMessenger.post(threadId, rendered.text);
+    }
+
+    // 6. Logger pour admin
+    await this.adminLogger.logQuery({
+      userId,
+      question: question.text,
+      sqls: [...agentResult.executedSqls],
+      rowCount: agentResult.queryResult?.rowCount ?? 0,
+      durationMs: Date.now() - startTime,
+      inputTokens: agentResult.inputTokens,
+      outputTokens: agentResult.outputTokens,
+    });
+  }
+}
+
+export default AnswerQuestion;

package/src/application/usecases/ParseQuestion.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import ParseQuestion from "../usecases/ParseQuestion.js";
+
+describe(`ParseQuestion`, () => {
+  it(`strips single mention`, () => {
+    const q = ParseQuestion.execute(`<@U123456> Combien de commandes ?`);
+    expect(q.text).toBe(`Combien de commandes ?`);
+  });
+
+  it(`strips multiple mentions`, () => {
+    const q = ParseQuestion.execute(`<@U123456> <@U789ABC> Combien ?`);
+    expect(q.text).toBe(`Combien ?`);
+  });
+
+  it(`preserves flags`, () => {
+    const q = ParseQuestion.execute(`<@U123456> Combien ? --sql`);
+    expect(q.flags.showSql).toBe(true);
+    expect(q.text).toBe(`Combien ?`);
+  });
+
+  it(`handles text without mention`, () => {
+    const q = ParseQuestion.execute(`Combien de commandes ?`);
+    expect(q.text).toBe(`Combien de commandes ?`);
+  });
+
+  it(`preserves raw input unchanged`, () => {
+    const raw = `<@U123456> Combien ? --sql`;
+    const q = ParseQuestion.execute(raw);
+    expect(q.raw).toBe(raw);
+  });
+
+  it(`extracts all flags correctly`, () => {
+    const q = ParseQuestion.execute(`<@U123> test --sql --debug --no-context`);
+    expect(q.flags.showSql).toBe(true);
+    expect(q.flags.debug).toBe(true);
+    expect(q.flags.noContext).toBe(true);
+    expect(q.text).toBe(`test`);
+  });
+});

package/src/application/usecases/ParseQuestion.ts

@@ -0,0 +1,9 @@
+import Question from "@/domain/value-objects/Question.js";
+
+class ParseQuestion {
+  static execute(rawText: string): Question {
+    return Question.create(rawText);
+  }
+}
+
+export default ParseQuestion;

package/src/config/Container.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { createContainer } from "./Container.js";
+
+describe("Container", () => {
+  describe("createContainer()", () => {
+    it("should instantiate all services without throwing", () => {
+      expect(() => {
+        createContainer();
+      }).not.toThrow();
+    });
+
+    it("should return app, answerQuestion, and logger", () => {
+      const container = createContainer();
+
+      expect(container).toHaveProperty("app");
+      expect(container).toHaveProperty("answerQuestion");
+      expect(container).toHaveProperty("logger");
+    });
+
+    it("should return a logger instance with methods", () => {
+      const { logger } = createContainer();
+
+      expect(typeof logger.debug).toBe("function");
+      expect(typeof logger.info).toBe("function");
+      expect(typeof logger.warn).toBe("function");
+      expect(typeof logger.error).toBe("function");
+    });
+
+    it("should wire answerQuestion with all dependencies", () => {
+      const { answerQuestion } = createContainer();
+
+      expect(typeof answerQuestion.execute).toBe("function");
+    });
+  });
+});

package/src/config/Container.ts

@@ -0,0 +1,74 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { env } from "./env.js";
+import PinoLogger from "@/infrastructure/logging/PinoLogger.js";
+import FileSystemSchemaCatalog from "@/infrastructure/schemas/FileSystemSchemaCatalog.js";
+import RegexSqlValidator from "@/infrastructure/sql/RegexSqlValidator.js";
+import createPool from "@/infrastructure/persistence/PostgresPoolFactory.js";
+import PostgresSqlExecutor from "@/infrastructure/persistence/PostgresSqlExecutor.js";
+import InMemoryConversationRepository from "@/infrastructure/persistence/InMemoryConversationRepository.js";
+import AnthropicLLMProvider from "@/infrastructure/llm/AnthropicLLMProvider.js";
+import createSlackApp from "@/infrastructure/slack/SlackApp.js";
+import BoltSlackMessenger from "@/infrastructure/slack/BoltSlackMessenger.js";
+import SlackAdminLogger from "@/infrastructure/slack/SlackAdminLogger.js";
+import AgentLoop from "@/application/agent/AgentLoop.js";
+import ResponseRenderer from "@/application/formatting/ResponseRenderer.js";
+import AnswerQuestion from "@/application/usecases/AnswerQuestion.js";
+
+export function createContainer() {
+  const logger = new PinoLogger(env.LOG_LEVEL);
+
+  const schemaCatalog = new FileSystemSchemaCatalog(env.SCHEMAS_DIR);
+
+  const sqlValidator = new RegexSqlValidator();
+
+  const pool = createPool(env.DATABASE_URL);
+  const sqlExecutor = new PostgresSqlExecutor(pool, env.SQL_TIMEOUT_MS);
+
+  const conversationRepository = new InMemoryConversationRepository(
+    env.CONVERSATION_MAX_THREADS,
+    env.CONVERSATION_TTL_MS,
+  );
+
+  const anthropicClient = new Anthropic({
+    apiKey: env.ANTHROPIC_API_KEY,
+  });
+
+  const llmProvider = new AnthropicLLMProvider(
+    anthropicClient,
+    env.LLM_MODEL,
+    schemaCatalog,
+  );
+
+  const { app } = createSlackApp(env.SLACK_BOT_TOKEN, env.SLACK_SIGNING_SECRET);
+
+  const slackMessenger = new BoltSlackMessenger(app.client);
+
+  const adminLogger = new SlackAdminLogger(
+    app.client,
+    env.SLACK_ADMIN_CHANNEL_ID ?? null,
+  );
+
+  const agentLoop = new AgentLoop(
+    llmProvider,
+    sqlValidator,
+    sqlExecutor,
+    schemaCatalog,
+    env.AGENT_MAX_TURNS,
+  );
+
+  const responseRenderer = new ResponseRenderer(env.SQL_CSV_THRESHOLD);
+
+  const answerQuestion = new AnswerQuestion(
+    conversationRepository,
+    agentLoop,
+    responseRenderer,
+    slackMessenger,
+    adminLogger,
+  );
+
+  return {
+    app,
+    answerQuestion,
+    logger,
+  };
+}

package/src/config/constants.ts

@@ -0,0 +1,9 @@
+import { env } from './env.js';
+
+export const SQL_MAX_ROWS = env.SQL_MAX_ROWS;
+export const SQL_TIMEOUT_MS = env.SQL_TIMEOUT_MS;
+export const SQL_CSV_THRESHOLD = env.SQL_CSV_THRESHOLD;
+export const AGENT_MAX_TURNS = env.AGENT_MAX_TURNS;
+export const CONVERSATION_TTL_MS = env.CONVERSATION_TTL_MS;
+export const CONVERSATION_MAX_THREADS = env.CONVERSATION_MAX_THREADS;
+export const CONVERSATION_MAX_MESSAGES = env.CONVERSATION_MAX_MESSAGES;