efarmz-slackbot-data 1.0.0

package/docs/schemas/example.md

@@ -0,0 +1,16 @@
+# Schema Documentation Example
+
+This is a placeholder schema documentation file. Replace with actual efarmz database schema documentation.
+
+## Tables
+
+### Example Table
+- Column 1: Description
+- Column 2: Description
+
+## Queries
+
+Common queries for analysis:
+```sql
+SELECT * FROM example_table LIMIT 100;
+```

package/eslint.config.mjs

@@ -0,0 +1,18 @@
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.strictTypeChecked,
+  {
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+  {
+    ignores: ['dist/', 'node_modules/'],
+  }
+);

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "efarmz-slackbot-data",
+  "version": "1.0.0",
+  "description": "Bot Slack qui traduit des questions en langage naturel vers des requêtes SQL via LLM",
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/main.ts",
+    "build": "tsc && tsc-alias --resolve-full-paths",
+    "start": "node dist/main.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "slack",
+    "llm",
+    "sql",
+    "anthropic"
+  ],
+  "author": "Benjamin Marguerite",
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.28.0",
+    "@slack/bolt": "^3.20.0",
+    "dotenv": "^17.4.2",
+    "pg": "^8.12.0",
+    "pino": "^9.5.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.14.0",
+    "@semantic-release/changelog": "^6.0.2",
+    "@semantic-release/commit-analyzer": "^9.0.2",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^10.0.3",
+    "@semantic-release/npm": "^9.0.2",
+    "@semantic-release/release-notes-generator": "^10.0.3",
+    "@types/node": "^22.9.0",
+    "@types/pg": "^8.12.1",
+    "@typescript-eslint/eslint-plugin": "^8.14.0",
+    "@typescript-eslint/parser": "^8.14.0",
+    "eslint": "^9.14.0",
+    "prettier": "^3.3.3",
+    "tsc-alias": "^1.8.17",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3",
+    "typescript-eslint": "^8.14.0",
+    "vitest": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}

package/releaserc.json

@@ -0,0 +1,15 @@
+{
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/changelog",
+    "@semantic-release/release-notes-generator",
+    "@semantic-release/git",
+    [
+      "@semantic-release/github",
+      {
+        "successComment": false,
+        "failTitle": false
+      }
+    ]
+  ]
+}

package/src/application/agent/AgentContext.test.ts

@@ -0,0 +1,263 @@
+import { describe, it, expect } from "vitest";
+import AgentContext from "../agent/AgentContext.js";
+import Conversation from "@/domain/entities/Conversation.js";
+import ConversationMessage from "@/domain/entities/ConversationMessage.js";
+import Question from "@/domain/value-objects/Question.js";
+import QueryResult from "@/domain/value-objects/QueryResult.js";
+import ThreadId from "@/domain/value-objects/ThreadId.js";
+
+describe(`AgentContext`, () => {
+  describe(`init()`, () => {
+    it(`should create context with single user message when no conversation exists`, () => {
+      const question = Question.create(`How many orders yesterday?`);
+      const ctx = AgentContext.init(null, question);
+
+      expect(ctx.messages).toHaveLength(1);
+      expect(ctx.messages[0]).toEqual({
+        role: `user`,
+        content: `How many orders yesterday?`,
+      });
+    });
+
+    it(`should preserve conversation message order when creating context`, () => {
+      const threadId = ThreadId.create(`C0123456789`, `1234567890.123456`);
+      let conversation = Conversation.create(threadId);
+      conversation = conversation.append(
+        ConversationMessage.create(`user`, `First question`),
+      );
+      conversation = conversation.append(
+        ConversationMessage.create(`assistant`, `First answer`),
+      );
+      conversation = conversation.append(
+        ConversationMessage.create(`user`, `Second question`),
+      );
+
+      const question = Question.create(`Third question`);
+      const ctx = AgentContext.init(conversation, question);
+
+      expect(ctx.messages).toHaveLength(4);
+      expect(ctx.messages[0]).toEqual({
+        role: `user`,
+        content: `First question`,
+      });
+      expect(ctx.messages[1]).toEqual({
+        role: `assistant`,
+        content: `First answer`,
+      });
+      expect(ctx.messages[2]).toEqual({
+        role: `user`,
+        content: `Second question`,
+      });
+      expect(ctx.messages[3]).toEqual({
+        role: `user`,
+        content: `Third question`,
+      });
+    });
+
+    it(`should initialize with zero tokens`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      expect(ctx.totalInputTokens).toBe(0);
+      expect(ctx.totalOutputTokens).toBe(0);
+    });
+
+    it(`should initialize with empty executed sqls`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      expect(ctx.executedSqls).toHaveLength(0);
+    });
+
+    it(`should initialize with null last query result`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      expect(ctx.lastQueryResult).toBeNull();
+    });
+  });
+
+  describe(`appendAssistantMessage()`, () => {
+    it(`should add assistant message to messages array`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      ctx.appendAssistantMessage(`This is an answer`, 100, 50);
+
+      expect(ctx.messages).toHaveLength(2);
+      expect(ctx.messages[1]).toEqual({
+        role: `assistant`,
+        content: `This is an answer`,
+      });
+    });
+
+    it(`should increment token counters`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      ctx.appendAssistantMessage(`Answer 1`, 100, 50);
+      ctx.appendAssistantMessage(`Answer 2`, 80, 40);
+
+      expect(ctx.totalInputTokens).toBe(180);
+      expect(ctx.totalOutputTokens).toBe(90);
+    });
+
+    it(`should accumulate tokens correctly across multiple calls`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      ctx.appendAssistantMessage(`Answer 1`, 100, 50);
+      expect(ctx.totalInputTokens).toBe(100);
+      expect(ctx.totalOutputTokens).toBe(50);
+
+      ctx.appendAssistantMessage(`Answer 2`, 100, 50);
+      expect(ctx.totalInputTokens).toBe(200);
+      expect(ctx.totalOutputTokens).toBe(100);
+    });
+  });
+
+  describe(`appendToolResult()`, () => {
+    it(`should add tool result message with isError false`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      ctx.appendToolResult(`tool_123`, `Query executed successfully`, false);
+
+      expect(ctx.messages).toHaveLength(2);
+      expect(ctx.messages[1]).toEqual({
+        role: `user`,
+        content: {
+          type: `tool_result`,
+          toolUseId: `tool_123`,
+          content: `Query executed successfully`,
+          isError: false,
+        },
+      });
+    });
+
+    it(`should add tool result message with isError true`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      ctx.appendToolResult(`tool_456`, `SQL syntax error`, true);
+
+      expect(ctx.messages).toHaveLength(2);
+      const msg = ctx.messages[1];
+      if (!msg) throw new Error(`Expected message at index 1`);
+      expect(msg.role).toBe(`user`);
+      if (typeof msg.content !== `string`) {
+        expect(msg.content.isError).toBe(true);
+        expect(msg.content.content).toBe(`SQL syntax error`);
+      }
+    });
+  });
+
+  describe(`recordSql()`, () => {
+    it(`should add sql to executed sqls list`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      const result = QueryResult.create([`id`, `name`], [
+        { id: 1, name: `Alice` },
+      ]);
+      ctx.recordSql(`SELECT * FROM users`, result);
+
+      expect(ctx.executedSqls).toHaveLength(1);
+      expect(ctx.executedSqls[0]).toBe(`SELECT * FROM users`);
+    });
+
+    it(`should update last query result`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      const result1 = QueryResult.create([`id`], [{ id: 1 }]);
+      ctx.recordSql(`SELECT 1`, result1);
+
+      expect(ctx.lastQueryResult).toBe(result1);
+    });
+
+    it(`should replace last query result when new sql is recorded`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      const result1 = QueryResult.create([`id`], [{ id: 1 }]);
+      const result2 = QueryResult.create([`id`], [{ id: 2 }, { id: 3 }]);
+
+      ctx.recordSql(`SELECT 1`, result1);
+      expect(ctx.lastQueryResult).toBe(result1);
+
+      ctx.recordSql(`SELECT 2, 3`, result2);
+      expect(ctx.lastQueryResult).toBe(result2);
+    });
+
+    it(`should track multiple sqls in order`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      const result = QueryResult.create([], []);
+      ctx.recordSql(`SELECT 1`, result);
+      ctx.recordSql(`SELECT 2`, result);
+      ctx.recordSql(`SELECT 3`, result);
+
+      expect(ctx.executedSqls).toEqual([`SELECT 1`, `SELECT 2`, `SELECT 3`]);
+    });
+  });
+
+  describe(`integration`, () => {
+    it(`should accumulate state correctly through a full agent loop simulation`, () => {
+      const threadId = ThreadId.create(`C0123456789`, `1234567890.123456`);
+      let conversation = Conversation.create(threadId);
+      conversation = conversation.append(
+        ConversationMessage.create(`user`, `Previous question`),
+      );
+      conversation = conversation.append(
+        ConversationMessage.create(`assistant`, `Previous answer`),
+      );
+
+      const question = Question.create(`New question`);
+      const ctx = AgentContext.init(conversation, question);
+
+      // Simulate first LLM turn
+      ctx.appendAssistantMessage(
+        `I will run a query to answer this.`,
+        150,
+        100,
+      );
+
+      // Simulate tool use and result
+      const queryResult = QueryResult.create(
+        [`count`],
+        [{ count: 42 }],
+      );
+      ctx.recordSql(`SELECT COUNT(*) as count FROM orders`, queryResult);
+      ctx.appendToolResult(`tool_use_1`, `42`, false);
+
+      // Simulate final turn
+      ctx.appendAssistantMessage(
+        `There are 42 orders.`,
+        100,
+        60,
+      );
+
+      // Verify final state
+      expect(ctx.messages).toHaveLength(6); // 2 from conversation + 1 initial question + 1 assistant answer + 1 tool result + 1 final answer
+      expect(ctx.totalInputTokens).toBe(250);
+      expect(ctx.totalOutputTokens).toBe(160);
+      expect(ctx.executedSqls).toEqual([
+        `SELECT COUNT(*) as count FROM orders`,
+      ]);
+      expect(ctx.lastQueryResult).toBe(queryResult);
+    });
+
+    it(`should return readonly views of internal arrays`, () => {
+      const question = Question.create(`Test`);
+      const ctx = AgentContext.init(null, question);
+
+      const messages = ctx.messages as unknown[];
+      const sqls = ctx.executedSqls as unknown[];
+
+      expect(Array.isArray(messages)).toBe(true);
+      expect(Array.isArray(sqls)).toBe(true);
+    });
+  });
+});

package/src/application/agent/AgentContext.ts

@@ -0,0 +1,93 @@
+import Conversation from "@/domain/entities/Conversation.js";
+import Question from "@/domain/value-objects/Question.js";
+import type QueryResult from "@/domain/value-objects/QueryResult.js";
+import type LLMMessage from "./LLMMessage.js";
+
+class AgentContext {
+  private readonly _messages: LLMMessage[] = [];
+  private readonly _executedSqls: string[] = [];
+  private _lastQueryResult: QueryResult | null = null;
+  private _totalInputTokens = 0;
+  private _totalOutputTokens = 0;
+
+  private constructor() {}
+
+  static init(conversation: Conversation | null, question: Question): AgentContext {
+    const ctx = new AgentContext();
+
+    if (conversation) {
+      for (const msg of conversation.messages) {
+        ctx._messages.push({
+          role: msg.role as `user` | `assistant`,
+          content: msg.content,
+        });
+      }
+    }
+
+    ctx._messages.push({
+      role: `user`,
+      content: question.text,
+    });
+
+    return ctx;
+  }
+
+  appendUserMessage(content: string): void {
+    this._messages.push({
+      role: `user`,
+      content,
+    });
+  }
+
+  appendAssistantMessage(
+    content: string,
+    inputTokens: number,
+    outputTokens: number,
+  ): void {
+    this._messages.push({
+      role: `assistant`,
+      content,
+    });
+    this._totalInputTokens += inputTokens;
+    this._totalOutputTokens += outputTokens;
+  }
+
+  appendToolResult(toolUseId: string, content: string, isError: boolean): void {
+    this._messages.push({
+      role: `user`,
+      content: {
+        type: `tool_result`,
+        toolUseId,
+        content,
+        isError,
+      },
+    });
+  }
+
+  recordSql(sql: string, result: QueryResult): void {
+    this._executedSqls.push(sql);
+    this._lastQueryResult = result;
+  }
+
+  get messages(): readonly LLMMessage[] {
+    return this._messages;
+  }
+
+  get executedSqls(): readonly string[] {
+    return this._executedSqls;
+  }
+
+  get lastQueryResult(): QueryResult | null {
+    return this._lastQueryResult;
+  }
+
+  get totalInputTokens(): number {
+    return this._totalInputTokens;
+  }
+
+  get totalOutputTokens(): number {
+    return this._totalOutputTokens;
+  }
+}
+
+export default AgentContext;