@maintainer-pro/ai-cli 0.1.0

package/dist/db-entry.cjs

@@ -0,0 +1,388 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/db/schema/pg.ts
+var pg_exports = {};
+__export(pg_exports, {
+  conversations: () => conversations,
+  messages: () => messages,
+  toolEvents: () => toolEvents
+});
+var import_pg_core, conversations, messages, toolEvents;
+var init_pg = __esm({
+  "src/db/schema/pg.ts"() {
+    "use strict";
+    import_pg_core = require("drizzle-orm/pg-core");
+    conversations = (0, import_pg_core.pgTable)("ai_cli_conversations", {
+      id: (0, import_pg_core.text)("id").primaryKey(),
+      createdAt: (0, import_pg_core.timestamp)("created_at", { withTimezone: true }).defaultNow().notNull(),
+      updatedAt: (0, import_pg_core.timestamp)("updated_at", { withTimezone: true }).defaultNow().notNull()
+    });
+    messages = (0, import_pg_core.pgTable)("ai_cli_messages", {
+      id: (0, import_pg_core.uuid)("id").defaultRandom().primaryKey(),
+      conversationId: (0, import_pg_core.text)("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
+      role: (0, import_pg_core.text)("role").notNull(),
+      content: (0, import_pg_core.text)("content").notNull(),
+      provider: (0, import_pg_core.text)("provider"),
+      createdAt: (0, import_pg_core.timestamp)("created_at", { withTimezone: true }).defaultNow().notNull()
+    });
+    toolEvents = (0, import_pg_core.pgTable)("ai_cli_tool_events", {
+      id: (0, import_pg_core.uuid)("id").defaultRandom().primaryKey(),
+      conversationId: (0, import_pg_core.text)("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
+      tool: (0, import_pg_core.text)("tool").notNull(),
+      args: (0, import_pg_core.jsonb)("args").$type().notNull(),
+      createdAt: (0, import_pg_core.timestamp)("created_at", { withTimezone: true }).defaultNow().notNull()
+    });
+  }
+});
+
+// src/db/schema/mysql.ts
+var mysql_exports = {};
+__export(mysql_exports, {
+  conversations: () => conversations2,
+  messages: () => messages2,
+  toolEvents: () => toolEvents2
+});
+var import_mysql_core, import_drizzle_orm, conversations2, messages2, toolEvents2;
+var init_mysql = __esm({
+  "src/db/schema/mysql.ts"() {
+    "use strict";
+    import_mysql_core = require("drizzle-orm/mysql-core");
+    import_drizzle_orm = require("drizzle-orm");
+    conversations2 = (0, import_mysql_core.mysqlTable)("ai_cli_conversations", {
+      id: (0, import_mysql_core.varchar)("id", { length: 128 }).primaryKey(),
+      createdAt: (0, import_mysql_core.timestamp)("created_at").default(import_drizzle_orm.sql`CURRENT_TIMESTAMP`).notNull(),
+      updatedAt: (0, import_mysql_core.timestamp)("updated_at").default(import_drizzle_orm.sql`CURRENT_TIMESTAMP`).notNull()
+    });
+    messages2 = (0, import_mysql_core.mysqlTable)("ai_cli_messages", {
+      id: (0, import_mysql_core.varchar)("id", { length: 36 }).primaryKey(),
+      conversationId: (0, import_mysql_core.varchar)("conversation_id", { length: 128 }).notNull(),
+      role: (0, import_mysql_core.varchar)("role", { length: 32 }).notNull(),
+      content: (0, import_mysql_core.text)("content").notNull(),
+      provider: (0, import_mysql_core.varchar)("provider", { length: 64 }),
+      createdAt: (0, import_mysql_core.timestamp)("created_at").default(import_drizzle_orm.sql`CURRENT_TIMESTAMP`).notNull()
+    });
+    toolEvents2 = (0, import_mysql_core.mysqlTable)("ai_cli_tool_events", {
+      id: (0, import_mysql_core.varchar)("id", { length: 36 }).primaryKey(),
+      conversationId: (0, import_mysql_core.varchar)("conversation_id", { length: 128 }).notNull(),
+      tool: (0, import_mysql_core.varchar)("tool", { length: 128 }).notNull(),
+      args: (0, import_mysql_core.json)("args").$type().notNull(),
+      createdAt: (0, import_mysql_core.timestamp)("created_at").default(import_drizzle_orm.sql`CURRENT_TIMESTAMP`).notNull()
+    });
+  }
+});
+
+// src/db/schema/sqlite.ts
+var sqlite_exports = {};
+__export(sqlite_exports, {
+  conversations: () => conversations3,
+  messages: () => messages3,
+  toolEvents: () => toolEvents3
+});
+var import_sqlite_core, import_drizzle_orm2, conversations3, messages3, toolEvents3;
+var init_sqlite = __esm({
+  "src/db/schema/sqlite.ts"() {
+    "use strict";
+    import_sqlite_core = require("drizzle-orm/sqlite-core");
+    import_drizzle_orm2 = require("drizzle-orm");
+    conversations3 = (0, import_sqlite_core.sqliteTable)("ai_cli_conversations", {
+      id: (0, import_sqlite_core.text)("id").primaryKey(),
+      createdAt: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).default(import_drizzle_orm2.sql`(unixepoch() * 1000)`).notNull(),
+      updatedAt: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }).default(import_drizzle_orm2.sql`(unixepoch() * 1000)`).notNull()
+    });
+    messages3 = (0, import_sqlite_core.sqliteTable)("ai_cli_messages", {
+      id: (0, import_sqlite_core.text)("id").primaryKey(),
+      conversationId: (0, import_sqlite_core.text)("conversation_id").notNull(),
+      role: (0, import_sqlite_core.text)("role").notNull(),
+      content: (0, import_sqlite_core.text)("content").notNull(),
+      provider: (0, import_sqlite_core.text)("provider"),
+      createdAt: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).default(import_drizzle_orm2.sql`(unixepoch() * 1000)`).notNull()
+    });
+    toolEvents3 = (0, import_sqlite_core.sqliteTable)("ai_cli_tool_events", {
+      id: (0, import_sqlite_core.text)("id").primaryKey(),
+      conversationId: (0, import_sqlite_core.text)("conversation_id").notNull(),
+      tool: (0, import_sqlite_core.text)("tool").notNull(),
+      args: (0, import_sqlite_core.text)("args", { mode: "json" }).$type().notNull(),
+      createdAt: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).default(import_drizzle_orm2.sql`(unixepoch() * 1000)`).notNull()
+    });
+  }
+});
+
+// src/db-entry.ts
+var db_entry_exports = {};
+__export(db_entry_exports, {
+  createAiCliDb: () => createAiCliDb,
+  createAiCliDbFromEnv: () => createAiCliDbFromEnv,
+  runMigrations: () => runMigrations,
+  runMigrationsFromEnv: () => runMigrationsFromEnv
+});
+module.exports = __toCommonJS(db_entry_exports);
+
+// src/db/client.ts
+var import_node_crypto = require("crypto");
+var import_drizzle_orm3 = require("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 Promise.resolve().then(() => (init_pg(), pg_exports));
+  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((0, import_drizzle_orm3.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 Promise.resolve().then(() => (init_mysql(), mysql_exports));
+  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 = (0, import_node_crypto.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((0, import_drizzle_orm3.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: (0, import_node_crypto.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 Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
+  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 = (0, import_node_crypto.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((0, import_drizzle_orm3.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: (0, import_node_crypto.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
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+function migrationsDir() {
+  const candidates = [
+    import_node_path.default.join(__dirname, "..", "drizzle"),
+    import_node_path.default.join(process.cwd(), "drizzle"),
+    import_node_path.default.join(process.cwd(), "packages", "ai-cli", "drizzle")
+  ];
+  for (const dir of candidates) {
+    if (import_node_fs.default.existsSync(dir)) return dir;
+  }
+  throw new Error("Could not locate ai-cli drizzle migrations folder");
+}
+async function runMigrations(options) {
+  const sqlPath = import_node_path.default.join(migrationsDir(), options.dialect, "0001_init.sql");
+  if (!import_node_fs.default.existsSync(sqlPath)) {
+    throw new Error(`Migration file missing: ${sqlPath}`);
+  }
+  const sql3 = import_node_fs.default.readFileSync(sqlPath, "utf8");
+  if (options.dialect === "postgres") {
+    const postgres = (await import("postgres")).default;
+    const client = postgres(options.url, { max: 1 });
+    try {
+      await client.unsafe(sql3);
+    } 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 sql3.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(sql3);
+  } 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 });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAiCliDb,
+  createAiCliDbFromEnv,
+  runMigrations,
+  runMigrationsFromEnv
+});

package/dist/db-entry.d.cts

@@ -0,0 +1,43 @@
+type DbDialect = "postgres" | "mysql" | "sqlite";
+interface SaveMessageInput {
+    conversationId: string;
+    role: "user" | "assistant" | "system";
+    content: string;
+    provider?: string;
+}
+interface StoredMessage {
+    id: string;
+    conversationId: string;
+    role: string;
+    content: string;
+    provider: string | null;
+    createdAt: Date;
+}
+interface ToolEventInput {
+    tool: string;
+    args: Record<string, unknown>;
+}
+/** Persistence API used by createChatHandler. */
+interface AiCliStore {
+    ensureConversation(id: string): Promise<void>;
+    saveMessage(input: SaveMessageInput): Promise<StoredMessage>;
+    listMessages(conversationId: string): Promise<StoredMessage[]>;
+    saveToolEvents?(conversationId: string, events: ToolEventInput[]): Promise<void>;
+}
+interface CreateAiCliDbOptions {
+    dialect: DbDialect;
+    /** Connection URL, or file path for sqlite (e.g. file:./ai-cli.db). */
+    url: string;
+}
+
+declare function createAiCliDb(options: CreateAiCliDbOptions): Promise<AiCliStore>;
+declare function createAiCliDbFromEnv(): Promise<AiCliStore> | null;
+
+/** Apply SQL migrations for the selected dialect. */
+declare function runMigrations(options: {
+    dialect: DbDialect;
+    url: string;
+}): Promise<void>;
+declare function runMigrationsFromEnv(): Promise<void>;
+
+export { type AiCliStore, type CreateAiCliDbOptions, type DbDialect, type SaveMessageInput, type StoredMessage, type ToolEventInput, createAiCliDb, createAiCliDbFromEnv, runMigrations, runMigrationsFromEnv };

package/dist/db-entry.d.ts

@@ -0,0 +1,43 @@
+type DbDialect = "postgres" | "mysql" | "sqlite";
+interface SaveMessageInput {
+    conversationId: string;
+    role: "user" | "assistant" | "system";
+    content: string;
+    provider?: string;
+}
+interface StoredMessage {
+    id: string;
+    conversationId: string;
+    role: string;
+    content: string;
+    provider: string | null;
+    createdAt: Date;
+}
+interface ToolEventInput {
+    tool: string;
+    args: Record<string, unknown>;
+}
+/** Persistence API used by createChatHandler. */
+interface AiCliStore {
+    ensureConversation(id: string): Promise<void>;
+    saveMessage(input: SaveMessageInput): Promise<StoredMessage>;
+    listMessages(conversationId: string): Promise<StoredMessage[]>;
+    saveToolEvents?(conversationId: string, events: ToolEventInput[]): Promise<void>;
+}
+interface CreateAiCliDbOptions {
+    dialect: DbDialect;
+    /** Connection URL, or file path for sqlite (e.g. file:./ai-cli.db). */
+    url: string;
+}
+
+declare function createAiCliDb(options: CreateAiCliDbOptions): Promise<AiCliStore>;
+declare function createAiCliDbFromEnv(): Promise<AiCliStore> | null;
+
+/** Apply SQL migrations for the selected dialect. */
+declare function runMigrations(options: {
+    dialect: DbDialect;
+    url: string;
+}): Promise<void>;
+declare function runMigrationsFromEnv(): Promise<void>;
+
+export { type AiCliStore, type CreateAiCliDbOptions, type DbDialect, type SaveMessageInput, type StoredMessage, type ToolEventInput, createAiCliDb, createAiCliDbFromEnv, runMigrations, runMigrationsFromEnv };