efarmz-slackbot-data 1.0.0

package/src/config/env.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod';
+
+describe(`env.ts`, () => {
+  const validEnv = {
+    SLACK_BOT_TOKEN: `xoxb-test-token`,
+    SLACK_SIGNING_SECRET: `test-secret`,
+    ANTHROPIC_API_KEY: `sk-ant-test-key`,
+    DATABASE_URL: `postgres://user:pass@localhost:5432/db`,
+  };
+
+  it(`should validate with all required variables`, () => {
+    const envSchema = z.object({
+      PORT: z.coerce.number().int().positive().default(3000),
+      NODE_ENV: z.enum([`development`, `production`, `test`]).default(`development`),
+      LOG_LEVEL: z.enum([`debug`, `info`, `warn`, `error`]).default(`info`),
+
+      SLACK_BOT_TOKEN: z.string().min(1, `SLACK_BOT_TOKEN is required`),
+      SLACK_SIGNING_SECRET: z.string().min(1, `SLACK_SIGNING_SECRET is required`),
+      SLACK_ADMIN_CHANNEL_ID: z.string().optional(),
+
+      LLM_MODEL: z.string().default(`claude-haiku-4-5-20251001`),
+      ANTHROPIC_API_KEY: z.string().min(1, `ANTHROPIC_API_KEY is required`),
+      AGENT_MAX_TURNS: z.coerce.number().int().positive().default(5),
+
+      DATABASE_URL: z.string().url(`DATABASE_URL must be a valid URL`),
+      SQL_TIMEOUT_MS: z.coerce.number().int().positive().default(30000),
+      SQL_MAX_ROWS: z.coerce.number().int().positive().default(100),
+      SQL_CSV_THRESHOLD: z.coerce.number().int().positive().default(15),
+
+      CONVERSATION_MAX_MESSAGES: z.coerce.number().int().positive().default(8),
+      CONVERSATION_TTL_MS: z.coerce.number().int().positive().default(3600000),
+      CONVERSATION_MAX_THREADS: z.coerce.number().int().positive().default(200),
+
+      SCHEMAS_DIR: z.string().default(`./docs/schemas`),
+    });
+
+    const result = envSchema.safeParse(validEnv);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.SLACK_BOT_TOKEN).toBe(`xoxb-test-token`);
+      expect(result.data.PORT).toBe(3000);
+      expect(result.data.LOG_LEVEL).toBe(`info`);
+    }
+  });
+
+  it(`should fail if SLACK_BOT_TOKEN is missing`, () => {
+    const envSchema = z.object({
+      SLACK_BOT_TOKEN: z.string().min(1, `SLACK_BOT_TOKEN is required`),
+      SLACK_SIGNING_SECRET: z.string().min(1, `SLACK_SIGNING_SECRET is required`),
+      ANTHROPIC_API_KEY: z.string().min(1, `ANTHROPIC_API_KEY is required`),
+      DATABASE_URL: z.string().url(`DATABASE_URL must be a valid URL`),
+      PORT: z.coerce.number().int().positive().default(3000),
+      NODE_ENV: z.enum([`development`, `production`, `test`]).default(`development`),
+      LOG_LEVEL: z.enum([`debug`, `info`, `warn`, `error`]).default(`info`),
+      SLACK_ADMIN_CHANNEL_ID: z.string().optional(),
+      LLM_MODEL: z.string().default(`claude-haiku-4-5-20251001`),
+      AGENT_MAX_TURNS: z.coerce.number().int().positive().default(5),
+      SQL_TIMEOUT_MS: z.coerce.number().int().positive().default(30000),
+      SQL_MAX_ROWS: z.coerce.number().int().positive().default(100),
+      SQL_CSV_THRESHOLD: z.coerce.number().int().positive().default(15),
+      CONVERSATION_MAX_MESSAGES: z.coerce.number().int().positive().default(8),
+      CONVERSATION_TTL_MS: z.coerce.number().int().positive().default(3600000),
+      CONVERSATION_MAX_THREADS: z.coerce.number().int().positive().default(200),
+      SCHEMAS_DIR: z.string().default(`./docs/schemas`),
+    });
+
+    const { SLACK_BOT_TOKEN, ...envWithoutToken } = validEnv;
+    const result = envSchema.safeParse(envWithoutToken);
+    expect(result.success).toBe(false);
+  });
+
+  it(`should apply defaults correctly`, () => {
+    const envSchema = z.object({
+      PORT: z.coerce.number().int().positive().default(3000),
+      NODE_ENV: z.enum([`development`, `production`, `test`]).default(`development`),
+      LOG_LEVEL: z.enum([`debug`, `info`, `warn`, `error`]).default(`info`),
+      SLACK_BOT_TOKEN: z.string().min(1),
+      SLACK_SIGNING_SECRET: z.string().min(1),
+      SLACK_ADMIN_CHANNEL_ID: z.string().optional(),
+      LLM_MODEL: z.string().default(`claude-haiku-4-5-20251001`),
+      ANTHROPIC_API_KEY: z.string().min(1),
+      AGENT_MAX_TURNS: z.coerce.number().int().positive().default(5),
+      DATABASE_URL: z.string().url(),
+      SQL_TIMEOUT_MS: z.coerce.number().int().positive().default(30000),
+      SQL_MAX_ROWS: z.coerce.number().int().positive().default(100),
+      SQL_CSV_THRESHOLD: z.coerce.number().int().positive().default(15),
+      CONVERSATION_MAX_MESSAGES: z.coerce.number().int().positive().default(8),
+      CONVERSATION_TTL_MS: z.coerce.number().int().positive().default(3600000),
+      CONVERSATION_MAX_THREADS: z.coerce.number().int().positive().default(200),
+      SCHEMAS_DIR: z.string().default(`./docs/schemas`),
+    });
+
+    const result = envSchema.safeParse(validEnv);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.PORT).toBe(3000);
+      expect(result.data.AGENT_MAX_TURNS).toBe(5);
+      expect(result.data.SQL_MAX_ROWS).toBe(100);
+      expect(result.data.SCHEMAS_DIR).toBe(`./docs/schemas`);
+    }
+  });
+});

package/src/config/env.ts

@@ -0,0 +1,41 @@
+import { config } from 'dotenv';
+import { z } from 'zod';
+
+config({ override: true });
+
+
+const envSchema = z.object({
+  PORT: z.coerce.number().int().positive().default(3000),
+  NODE_ENV: z.enum([`development`, `production`, `test`]).default(`development`),
+  LOG_LEVEL: z.enum([`debug`, `info`, `warn`, `error`]).default(`info`),
+
+  SLACK_BOT_TOKEN: z.string().min(1, `SLACK_BOT_TOKEN is required`),
+  SLACK_SIGNING_SECRET: z.string().min(1, `SLACK_SIGNING_SECRET is required`),
+  SLACK_ADMIN_CHANNEL_ID: z.string().optional(),
+
+  LLM_MODEL: z.string().default(`claude-haiku-4-5-20251001`),
+  ANTHROPIC_API_KEY: z.string().min(1, `ANTHROPIC_API_KEY is required`),
+  AGENT_MAX_TURNS: z.coerce.number().int().positive().default(5),
+
+  DATABASE_URL: z.string().url(`DATABASE_URL must be a valid URL`),
+  SQL_TIMEOUT_MS: z.coerce.number().int().positive().default(30000),
+  SQL_MAX_ROWS: z.coerce.number().int().positive().default(100),
+  SQL_CSV_THRESHOLD: z.coerce.number().int().positive().default(15),
+
+  CONVERSATION_MAX_MESSAGES: z.coerce.number().int().positive().default(8),
+  CONVERSATION_TTL_MS: z.coerce.number().int().positive().default(3600000),
+  CONVERSATION_MAX_THREADS: z.coerce.number().int().positive().default(200),
+
+  SCHEMAS_DIR: z.string().default(`./docs/schemas`),
+});
+
+const parsed = envSchema.safeParse(process.env);
+
+if (!parsed.success) {
+  console.error(`❌ Invalid environment variables:`);
+  console.error(parsed.error.format());
+  process.exit(1);
+}
+
+export const env = parsed.data;
+export type Env = z.infer<typeof envSchema>;

package/src/domain/entities/Conversation.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from "vitest";
+import Conversation, { CONVERSATION_MAX_MESSAGES } from "./Conversation.js";
+import ConversationMessage from "./ConversationMessage.js";
+import ThreadId from "../value-objects/ThreadId.js";
+
+describe("Conversation", () => {
+  it("creates an empty conversation with a thread ID", () => {
+    const threadId = ThreadId.create("C123", "1234567890.123456");
+    const conversation = Conversation.create(threadId);
+
+    expect(conversation.threadId).toBe(threadId);
+    expect(conversation.messages).toEqual([]);
+  });
+
+  it("appends a message to the conversation", () => {
+    const threadId = ThreadId.create("C123", "1234567890.123456");
+    const conversation = Conversation.create(threadId);
+    const message = ConversationMessage.create("user", "Hello");
+
+    const updated = conversation.append(message);
+
+    expect(updated.messages).toHaveLength(1);
+    expect(updated.messages[0]).toEqual(message);
+  });
+
+  it("maintains immutability - original conversation is unchanged", () => {
+    const threadId = ThreadId.create("C123", "1234567890.123456");
+    const conversation = Conversation.create(threadId);
+    const message = ConversationMessage.create("user", "Hello");
+
+    const updated = conversation.append(message);
+
+    expect(conversation.messages).toHaveLength(0);
+    expect(updated.messages).toHaveLength(1);
+  });
+
+  it("enforces LRU purge when exceeding max messages", () => {
+    const threadId = ThreadId.create("C123", "1234567890.123456");
+    let conversation = Conversation.create(threadId);
+
+    for (let i = 0; i < CONVERSATION_MAX_MESSAGES + 1; i += 1) {
+      const message = ConversationMessage.create("user", `Message ${String(i)}`);
+      conversation = conversation.append(message);
+    }
+
+    expect(conversation.messages).toHaveLength(CONVERSATION_MAX_MESSAGES);
+    expect(conversation.messages[0]?.content).toBe(`Message 1`);
+  });
+
+  it("preserves messages in order with multiple appends", () => {
+    const threadId = ThreadId.create("C123", "1234567890.123456");
+    let conversation = Conversation.create(threadId);
+
+    const messages = [
+      ConversationMessage.create("user", "First"),
+      ConversationMessage.create("assistant", "Second"),
+      ConversationMessage.create("user", "Third"),
+    ];
+
+    for (const msg of messages) {
+      conversation = conversation.append(msg);
+    }
+
+    expect(conversation.messages).toHaveLength(3);
+    expect(conversation.messages[0]?.content).toBe("First");
+    expect(conversation.messages[1]?.content).toBe("Second");
+    expect(conversation.messages[2]?.content).toBe("Third");
+  });
+});

package/src/domain/entities/Conversation.ts

@@ -0,0 +1,26 @@
+import ThreadId from "@/domain/value-objects/ThreadId.js";
+import type { ConversationMessage } from "./ConversationMessage.js";
+
+const CONVERSATION_MAX_MESSAGES = 10;
+
+class Conversation {
+  private constructor(
+    public readonly threadId: ThreadId,
+    public readonly messages: readonly ConversationMessage[],
+  ) {}
+
+  static create(threadId: ThreadId): Conversation {
+    return new Conversation(threadId, []);
+  }
+
+  append(message: ConversationMessage): Conversation {
+    const newMessages = [...this.messages, message];
+    if (newMessages.length > CONVERSATION_MAX_MESSAGES) {
+      newMessages.shift();
+    }
+    return new Conversation(this.threadId, newMessages);
+  }
+}
+
+export default Conversation;
+export { CONVERSATION_MAX_MESSAGES };

package/src/domain/entities/ConversationMessage.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import ConversationMessage from "./ConversationMessage.js";
+
+describe("ConversationMessage", () => {
+  let beforeTime: Date;
+  let afterTime: Date;
+
+  beforeEach(() => {
+    beforeTime = new Date();
+  });
+
+  it("creates a message with user role", () => {
+    const message = ConversationMessage.create("user", "Hello");
+
+    expect(message.role).toBe("user");
+    expect(message.content).toBe("Hello");
+    expect(message.timestamp).toBeInstanceOf(Date);
+  });
+
+  it("creates a message with assistant role", () => {
+    const message = ConversationMessage.create("assistant", "Hi there");
+
+    expect(message.role).toBe("assistant");
+    expect(message.content).toBe("Hi there");
+  });
+
+  it("timestamps the message at creation", () => {
+    beforeTime = new Date();
+    const message = ConversationMessage.create("user", "Test");
+    afterTime = new Date();
+
+    expect(message.timestamp.getTime()).toBeGreaterThanOrEqual(beforeTime.getTime());
+    expect(message.timestamp.getTime()).toBeLessThanOrEqual(afterTime.getTime());
+  });
+
+  it("preserves message content as-is", () => {
+    const content = "  Multiple   spaces  and\nnewlines\n\n  ";
+    const message = ConversationMessage.create("user", content);
+
+    expect(message.content).toBe(content);
+  });
+
+  it("handles empty content", () => {
+    const message = ConversationMessage.create("user", "");
+
+    expect(message.content).toBe("");
+    expect(message.role).toBe("user");
+  });
+});

package/src/domain/entities/ConversationMessage.ts

@@ -0,0 +1,18 @@
+interface ConversationMessage {
+  role: "user" | "assistant";
+  content: string;
+  timestamp: Date;
+}
+
+const ConversationMessage = {
+  create(role: "user" | "assistant", content: string): ConversationMessage {
+    return {
+      role,
+      content,
+      timestamp: new Date(),
+    };
+  },
+};
+
+export default ConversationMessage;
+export type { ConversationMessage };

package/src/domain/entities/index.ts

@@ -0,0 +1,2 @@
+export { default as Conversation, CONVERSATION_MAX_MESSAGES } from "./Conversation.js";
+export { default as ConversationMessage } from "./ConversationMessage.js";

package/src/domain/errors/AgentLoopExceededError.ts

@@ -0,0 +1,12 @@
+import DomainError from "./DomainError.js";
+
+class AgentLoopExceededError extends DomainError {
+  readonly code = `AGENT_LOOP_EXCEEDED`;
+
+  constructor(public readonly maxTurns: number) {
+    super(`Agent loop exceeded maximum turns (${maxTurns.toString()})`);
+    Object.setPrototypeOf(this, AgentLoopExceededError.prototype);
+  }
+}
+
+export default AgentLoopExceededError;

package/src/domain/errors/DomainError.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect } from "vitest";
+import {
+  DomainError,
+  InvalidSqlError,
+  SqlExecutionError,
+  LLMError,
+  SchemaLoadError,
+  AgentLoopExceededError,
+} from "./index.js";
+
+describe("DomainError hierarchy", () => {
+
+  describe("InvalidSqlError", () => {
+    it("should create instance with sql and reason", () => {
+      const error = new InvalidSqlError(`DROP TABLE users`, `mutation not allowed`);
+      expect(error.code).toBe(`INVALID_SQL`);
+      expect(error.sql).toBe(`DROP TABLE users`);
+      expect(error.reason).toBe(`mutation not allowed`);
+      expect(error.message).toBe(`Invalid SQL: mutation not allowed`);
+      expect(error).toBeInstanceOf(DomainError);
+      expect(error).toBeInstanceOf(Error);
+    });
+
+    it("should have correct name", () => {
+      const error = new InvalidSqlError(`DROP TABLE users`, `mutation not allowed`);
+      expect(error.name).toBe(`InvalidSqlError`);
+    });
+  });
+
+  describe("SqlExecutionError", () => {
+    it("should create instance with sql and pgError", () => {
+      const error = new SqlExecutionError(
+        `SELECT * FROM nonexistent`,
+        `relation "nonexistent" does not exist`,
+      );
+      expect(error.code).toBe(`SQL_EXECUTION_ERROR`);
+      expect(error.sql).toBe(`SELECT * FROM nonexistent`);
+      expect(error.pgError).toBe(`relation "nonexistent" does not exist`);
+      expect(error.message).toBe(
+        `SQL execution failed: relation "nonexistent" does not exist`,
+      );
+      expect(error).toBeInstanceOf(DomainError);
+    });
+  });
+
+  describe("LLMError", () => {
+    it("should create instance with provider and details", () => {
+      const error = new LLMError(`anthropic`, `rate limit exceeded`);
+      expect(error.code).toBe(`LLM_ERROR`);
+      expect(error.provider).toBe(`anthropic`);
+      expect(error.details).toBe(`rate limit exceeded`);
+      expect(error.message).toBe(`LLM error from anthropic: rate limit exceeded`);
+      expect(error).toBeInstanceOf(DomainError);
+    });
+  });
+
+  describe("SchemaLoadError", () => {
+    it("should create instance with schemaName and reason", () => {
+      const error = new SchemaLoadError(`efarmz_db`, `file not found`);
+      expect(error.code).toBe(`SCHEMA_LOAD_ERROR`);
+      expect(error.schemaName).toBe(`efarmz_db`);
+      expect(error.reason).toBe(`file not found`);
+      expect(error.message).toBe(`Failed to load schema efarmz_db: file not found`);
+      expect(error).toBeInstanceOf(DomainError);
+    });
+  });
+
+  describe("AgentLoopExceededError", () => {
+    it("should create instance with maxTurns", () => {
+      const error = new AgentLoopExceededError(10);
+      expect(error.code).toBe(`AGENT_LOOP_EXCEEDED`);
+      expect(error.maxTurns).toBe(10);
+      expect(error.message).toBe(`Agent loop exceeded maximum turns (10)`);
+      expect(error).toBeInstanceOf(DomainError);
+    });
+  });
+
+  it("all error codes should be unique", () => {
+    const codes = [
+      new InvalidSqlError(``, ``).code,
+      new SqlExecutionError(``, ``).code,
+      new LLMError(``, ``).code,
+      new SchemaLoadError(``, ``).code,
+      new AgentLoopExceededError(0).code,
+    ];
+    const uniqueCodes = new Set(codes);
+    expect(uniqueCodes.size).toBe(codes.length);
+  });
+
+  it("all errors should be instanceof DomainError", () => {
+    const errors: DomainError[] = [
+      new InvalidSqlError(``, ``),
+      new SqlExecutionError(``, ``),
+      new LLMError(``, ``),
+      new SchemaLoadError(``, ``),
+      new AgentLoopExceededError(0),
+    ];
+
+    for (const error of errors) {
+      expect(error).toBeInstanceOf(DomainError);
+      expect(error).toBeInstanceOf(Error);
+      expect(error.code).toBeDefined();
+      expect(typeof error.code).toBe(`string`);
+    }
+  });
+});

package/src/domain/errors/DomainError.ts

@@ -0,0 +1,11 @@
+abstract class DomainError extends Error {
+  abstract readonly code: string;
+
+  constructor(message: string) {
+    super(message);
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, DomainError.prototype);
+  }
+}
+
+export default DomainError;

package/src/domain/errors/InvalidSqlError.ts

@@ -0,0 +1,15 @@
+import DomainError from "./DomainError.js";
+
+class InvalidSqlError extends DomainError {
+  readonly code = `INVALID_SQL`;
+
+  constructor(
+    public readonly sql: string,
+    public readonly reason: string,
+  ) {
+    super(`Invalid SQL: ${reason}`);
+    Object.setPrototypeOf(this, InvalidSqlError.prototype);
+  }
+}
+
+export default InvalidSqlError;

package/src/domain/errors/LLMError.ts

@@ -0,0 +1,15 @@
+import DomainError from "./DomainError.js";
+
+class LLMError extends DomainError {
+  readonly code = `LLM_ERROR`;
+
+  constructor(
+    public readonly provider: string,
+    public readonly details: string,
+  ) {
+    super(`LLM error from ${provider}: ${details}`);
+    Object.setPrototypeOf(this, LLMError.prototype);
+  }
+}
+
+export default LLMError;

package/src/domain/errors/SchemaLoadError.ts

@@ -0,0 +1,15 @@
+import DomainError from "./DomainError.js";
+
+class SchemaLoadError extends DomainError {
+  readonly code = `SCHEMA_LOAD_ERROR`;
+
+  constructor(
+    public readonly schemaName: string,
+    public readonly reason: string,
+  ) {
+    super(`Failed to load schema ${schemaName}: ${reason}`);
+    Object.setPrototypeOf(this, SchemaLoadError.prototype);
+  }
+}
+
+export default SchemaLoadError;

package/src/domain/errors/SqlExecutionError.ts

@@ -0,0 +1,15 @@
+import DomainError from "./DomainError.js";
+
+class SqlExecutionError extends DomainError {
+  readonly code = `SQL_EXECUTION_ERROR`;
+
+  constructor(
+    public readonly sql: string,
+    public readonly pgError: string,
+  ) {
+    super(`SQL execution failed: ${pgError}`);
+    Object.setPrototypeOf(this, SqlExecutionError.prototype);
+  }
+}
+
+export default SqlExecutionError;

package/src/domain/errors/index.ts

@@ -0,0 +1,15 @@
+import DomainError from "./DomainError.js";
+import InvalidSqlError from "./InvalidSqlError.js";
+import SqlExecutionError from "./SqlExecutionError.js";
+import LLMError from "./LLMError.js";
+import SchemaLoadError from "./SchemaLoadError.js";
+import AgentLoopExceededError from "./AgentLoopExceededError.js";
+
+export {
+  DomainError,
+  InvalidSqlError,
+  SqlExecutionError,
+  LLMError,
+  SchemaLoadError,
+  AgentLoopExceededError,
+};

package/src/domain/ports/AdminLogger.ts

@@ -0,0 +1,16 @@
+interface AdminLogEntry {
+  userId: string;
+  question: string;
+  sqls: string[];
+  rowCount: number;
+  durationMs: number;
+  inputTokens: number;
+  outputTokens: number;
+}
+
+interface AdminLogger {
+  logQuery(entry: AdminLogEntry): Promise<void>;
+}
+
+export default AdminLogger;
+export type { AdminLogEntry };

package/src/domain/ports/ConversationRepository.ts

@@ -0,0 +1,10 @@
+import type ThreadId from "@/domain/value-objects/ThreadId.js";
+import type Conversation from "@/domain/entities/Conversation.js";
+
+interface ConversationRepository {
+  get(threadId: ThreadId): Promise<Conversation | null>;
+  save(conversation: Conversation): Promise<void>;
+  purge(threadId: ThreadId): Promise<void>;
+}
+
+export default ConversationRepository;

package/src/domain/ports/LLMProvider.ts

@@ -0,0 +1,33 @@
+interface LLMToolUse {
+  id: string;
+  name: string;
+  input: Record<string, unknown>;
+}
+
+interface LLMRequest {
+  systemPrompt: string;
+  messages: Array<{
+    role: "user" | "assistant";
+    content: string;
+  }>;
+  tools?: Array<{
+    name: string;
+    description: string;
+    inputSchema: object;
+  }>;
+}
+
+interface LLMResponse {
+  content: string;
+  toolUses: LLMToolUse[];
+  stopReason: "end_turn" | "tool_use" | "max_tokens";
+  inputTokens: number;
+  outputTokens: number;
+}
+
+interface LLMProvider {
+  generate(request: LLMRequest): Promise<LLMResponse>;
+}
+
+export default LLMProvider;
+export type { LLMToolUse, LLMRequest, LLMResponse };

package/src/domain/ports/Logger.ts

@@ -0,0 +1,8 @@
+interface Logger {
+  debug(msg: string, meta?: object): void;
+  info(msg: string, meta?: object): void;
+  warn(msg: string, meta?: object): void;
+  error(msg: string, meta?: object): void;
+}
+
+export default Logger;

package/src/domain/ports/SchemaCatalog.ts

@@ -0,0 +1,5 @@
+interface SchemaCatalog {
+  getDocumentation(): string;
+}
+
+export default SchemaCatalog;

package/src/domain/ports/SlackMessenger.ts

@@ -0,0 +1,8 @@
+import type ThreadId from "@/domain/value-objects/ThreadId.js";
+
+interface SlackMessenger {
+  post(threadId: ThreadId, text: string): Promise<void>;
+  postCsv(threadId: ThreadId, text: string, csvBuffer: Buffer, filename: string): Promise<void>;
+}
+
+export default SlackMessenger;

package/src/domain/ports/SqlExecutor.ts

@@ -0,0 +1,8 @@
+import type SqlQuery from "@/domain/value-objects/SqlQuery.js";
+import type { QueryResult } from "@/domain/value-objects/QueryResult.js";
+
+interface SqlExecutor {
+  execute(query: SqlQuery): Promise<QueryResult>;
+}
+
+export default SqlExecutor;

package/src/domain/ports/SqlValidator.ts

@@ -0,0 +1,5 @@
+interface SqlValidator {
+  validate(raw: string): string;
+}
+
+export default SqlValidator;

package/src/domain/ports/index.ts

@@ -0,0 +1,17 @@
+export { default as AdminLogger } from "./AdminLogger.js";
+export type { AdminLogEntry } from "./AdminLogger.js";
+
+export { default as ConversationRepository } from "./ConversationRepository.js";
+
+export { default as LLMProvider } from "./LLMProvider.js";
+export type { LLMRequest, LLMResponse, LLMToolUse } from "./LLMProvider.js";
+
+export { default as Logger } from "./Logger.js";
+
+export { default as SchemaCatalog } from "./SchemaCatalog.js";
+
+export { default as SlackMessenger } from "./SlackMessenger.js";
+
+export { default as SqlExecutor } from "./SqlExecutor.js";
+
+export { default as SqlValidator } from "./SqlValidator.js";

package/src/domain/value-objects/LLMProviderName.ts

@@ -0,0 +1,6 @@
+enum LLMProviderName {
+  ANTHROPIC = `anthropic`,
+  OPENAI = `openai`,
+}
+
+export default LLMProviderName;