@maintainer-pro/ai-cli 0.1.0

package/dist/db-entry.js

@@ -0,0 +1,238 @@
+// src/db/client.ts
+import { randomUUID } from "crypto";
+import { eq } from "drizzle-orm";
+function toStored(row) {
+  return {
+    id: row.id,
+    conversationId: row.conversationId,
+    role: row.role,
+    content: row.content,
+    provider: row.provider,
+    createdAt: row.createdAt instanceof Date ? row.createdAt : new Date(row.createdAt)
+  };
+}
+async function createPostgresStore(url) {
+  const { drizzle } = await import("drizzle-orm/postgres-js");
+  const postgres = (await import("postgres")).default;
+  const schema = await import("./pg-QSUOKTP3.js");
+  const client = postgres(url);
+  const db = drizzle(client, { schema });
+  return {
+    async ensureConversation(id) {
+      await db.insert(schema.conversations).values({ id }).onConflictDoNothing();
+    },
+    async saveMessage(input) {
+      const [row] = await db.insert(schema.messages).values({
+        conversationId: input.conversationId,
+        role: input.role,
+        content: input.content,
+        provider: input.provider
+      }).returning();
+      return toStored(row);
+    },
+    async listMessages(conversationId) {
+      const rows = await db.select().from(schema.messages).where(eq(schema.messages.conversationId, conversationId));
+      return rows.map(toStored);
+    },
+    async saveToolEvents(conversationId, events) {
+      if (events.length === 0) return;
+      await db.insert(schema.toolEvents).values(
+        events.map((e) => ({
+          conversationId,
+          tool: e.tool,
+          args: e.args
+        }))
+      );
+    }
+  };
+}
+async function createMysqlStore(url) {
+  const { drizzle } = await import("drizzle-orm/mysql2");
+  const mysql = await import("mysql2/promise");
+  const schema = await import("./mysql-EKKUF6CP.js");
+  const pool = mysql.createPool(url);
+  const db = drizzle(pool, { schema, mode: "default" });
+  return {
+    async ensureConversation(id) {
+      await db.insert(schema.conversations).values({ id }).onDuplicateKeyUpdate({
+        set: { updatedAt: /* @__PURE__ */ new Date() }
+      });
+    },
+    async saveMessage(input) {
+      const id = randomUUID();
+      await db.insert(schema.messages).values({
+        id,
+        conversationId: input.conversationId,
+        role: input.role,
+        content: input.content,
+        provider: input.provider ?? null
+      });
+      return {
+        id,
+        conversationId: input.conversationId,
+        role: input.role,
+        content: input.content,
+        provider: input.provider ?? null,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+    },
+    async listMessages(conversationId) {
+      const rows = await db.select().from(schema.messages).where(eq(schema.messages.conversationId, conversationId));
+      return rows.map(
+        (row) => toStored({
+          ...row,
+          provider: row.provider ?? null
+        })
+      );
+    },
+    async saveToolEvents(conversationId, events) {
+      if (events.length === 0) return;
+      await db.insert(schema.toolEvents).values(
+        events.map((e) => ({
+          id: randomUUID(),
+          conversationId,
+          tool: e.tool,
+          args: e.args
+        }))
+      );
+    }
+  };
+}
+async function createSqliteStore(url) {
+  const { drizzle } = await import("drizzle-orm/better-sqlite3");
+  const Database = (await import("better-sqlite3")).default;
+  const schema = await import("./sqlite-6L33HVYQ.js");
+  const file = url.replace(/^file:/, "");
+  const sqlite = new Database(file);
+  const db = drizzle(sqlite, { schema });
+  return {
+    async ensureConversation(id) {
+      await db.insert(schema.conversations).values({ id }).onConflictDoNothing();
+    },
+    async saveMessage(input) {
+      const id = randomUUID();
+      const [row] = await db.insert(schema.messages).values({
+        id,
+        conversationId: input.conversationId,
+        role: input.role,
+        content: input.content,
+        provider: input.provider ?? null
+      }).returning();
+      return toStored({
+        ...row,
+        provider: row.provider ?? null
+      });
+    },
+    async listMessages(conversationId) {
+      const rows = await db.select().from(schema.messages).where(eq(schema.messages.conversationId, conversationId));
+      return rows.map(
+        (row) => toStored({
+          ...row,
+          provider: row.provider ?? null
+        })
+      );
+    },
+    async saveToolEvents(conversationId, events) {
+      if (events.length === 0) return;
+      await db.insert(schema.toolEvents).values(
+        events.map((e) => ({
+          id: randomUUID(),
+          conversationId,
+          tool: e.tool,
+          args: e.args
+        }))
+      );
+    }
+  };
+}
+async function createAiCliDb(options) {
+  switch (options.dialect) {
+    case "postgres":
+      return createPostgresStore(options.url);
+    case "mysql":
+      return createMysqlStore(options.url);
+    case "sqlite":
+      return createSqliteStore(options.url);
+    default:
+      throw new Error(`Unsupported dialect: ${options.dialect}`);
+  }
+}
+function createAiCliDbFromEnv() {
+  const url = process.env.AI_CLI_DB_URL?.trim();
+  const dialect = process.env.AI_CLI_DB_DIALECT?.trim();
+  if (!url || !dialect) return null;
+  if (dialect !== "postgres" && dialect !== "mysql" && dialect !== "sqlite") {
+    throw new Error(
+      `Invalid AI_CLI_DB_DIALECT="${dialect}". Use postgres|mysql|sqlite.`
+    );
+  }
+  return createAiCliDb({ dialect, url });
+}
+
+// src/db/migrate.ts
+import fs from "fs";
+import path from "path";
+function migrationsDir() {
+  const candidates = [
+    path.join(__dirname, "..", "drizzle"),
+    path.join(process.cwd(), "drizzle"),
+    path.join(process.cwd(), "packages", "ai-cli", "drizzle")
+  ];
+  for (const dir of candidates) {
+    if (fs.existsSync(dir)) return dir;
+  }
+  throw new Error("Could not locate ai-cli drizzle migrations folder");
+}
+async function runMigrations(options) {
+  const sqlPath = path.join(migrationsDir(), options.dialect, "0001_init.sql");
+  if (!fs.existsSync(sqlPath)) {
+    throw new Error(`Migration file missing: ${sqlPath}`);
+  }
+  const sql = fs.readFileSync(sqlPath, "utf8");
+  if (options.dialect === "postgres") {
+    const postgres = (await import("postgres")).default;
+    const client = postgres(options.url, { max: 1 });
+    try {
+      await client.unsafe(sql);
+    } finally {
+      await client.end();
+    }
+    return;
+  }
+  if (options.dialect === "mysql") {
+    const mysql = await import("mysql2/promise");
+    const conn = await mysql.createConnection(options.url);
+    try {
+      for (const statement of sql.split(";").map((s) => s.trim()).filter(Boolean)) {
+        await conn.query(statement);
+      }
+    } finally {
+      await conn.end();
+    }
+    return;
+  }
+  const Database = (await import("better-sqlite3")).default;
+  const file = options.url.replace(/^file:/, "");
+  const db = new Database(file);
+  try {
+    db.exec(sql);
+  } finally {
+    db.close();
+  }
+}
+async function runMigrationsFromEnv() {
+  const url = process.env.AI_CLI_DB_URL?.trim();
+  const dialect = process.env.AI_CLI_DB_DIALECT?.trim();
+  if (!url || !dialect) {
+    throw new Error(
+      "Set AI_CLI_DB_URL and AI_CLI_DB_DIALECT to run migrations"
+    );
+  }
+  await runMigrations({ dialect, url });
+}
+export {
+  createAiCliDb,
+  createAiCliDbFromEnv,
+  runMigrations,
+  runMigrationsFromEnv
+};