agor-live 0.3.7

package/dist/core/dist/claude/index.cjs

@@ -0,0 +1,673 @@
+"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, desc2) => {
+  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: !(desc2 = __getOwnPropDesc(from, key)) || desc2.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/lib/ids.ts
+function generateId() {
+  return (0, import_uuidv7.uuidv7)();
+}
+var import_uuidv7;
+var init_ids = __esm({
+  "src/lib/ids.ts"() {
+    "use strict";
+    import_uuidv7 = require("uuidv7");
+  }
+});
+
+// src/claude/index.ts
+var claude_exports = {};
+__export(claude_exports, {
+  buildConversationTree: () => buildConversationTree,
+  extractTasksFromMessages: () => extractTasksFromMessages,
+  filterConversationMessages: () => filterConversationMessages,
+  getTranscriptPath: () => getTranscriptPath,
+  loadClaudeSession: () => loadClaudeSession,
+  loadSessionTranscript: () => loadSessionTranscript,
+  parseTranscript: () => parseTranscript,
+  transcriptToMessage: () => transcriptToMessage,
+  transcriptsToMessages: () => transcriptsToMessages
+});
+module.exports = __toCommonJS(claude_exports);
+
+// src/claude/transcript-parser.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_node_readline = __toESM(require("readline"), 1);
+function getTranscriptPath(sessionId, projectDir) {
+  const homeDir = process.env.HOME || process.env.USERPROFILE;
+  if (!homeDir) {
+    throw new Error("Could not determine home directory");
+  }
+  const cwd = projectDir || process.cwd();
+  const projectSlug = cwd.replace(/\//g, "-").replace(/\\/g, "-");
+  const transcriptPath = import_node_path.default.join(
+    homeDir,
+    ".claude",
+    "projects",
+    projectSlug,
+    `${sessionId}.jsonl`
+  );
+  return transcriptPath;
+}
+async function parseTranscript(transcriptPath) {
+  if (!import_node_fs.default.existsSync(transcriptPath)) {
+    throw new Error(`Transcript file not found: ${transcriptPath}`);
+  }
+  const messages2 = [];
+  const fileStream = import_node_fs.default.createReadStream(transcriptPath);
+  const rl = import_node_readline.default.createInterface({
+    input: fileStream,
+    crlfDelay: Number.POSITIVE_INFINITY
+  });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    try {
+      const message = JSON.parse(line);
+      messages2.push(message);
+    } catch (error) {
+      console.error(`Failed to parse line: ${line.substring(0, 100)}...`);
+      throw error;
+    }
+  }
+  return messages2;
+}
+async function loadSessionTranscript(sessionId, projectDir) {
+  const transcriptPath = getTranscriptPath(sessionId, projectDir);
+  return parseTranscript(transcriptPath);
+}
+function filterConversationMessages(messages2) {
+  return messages2.filter((msg) => {
+    if (msg.type === "file-history-snapshot") return false;
+    if (msg.isMeta) return false;
+    const content = msg.message?.content;
+    if (Array.isArray(content) && content.some((c) => c.type === "tool_result")) {
+      return false;
+    }
+    if (typeof content === "string") {
+      if (content.trim().match(/^<(command-name|local-command-stdout|system-reminder)/)) {
+        return false;
+      }
+    }
+    return msg.type === "user" || msg.type === "assistant";
+  });
+}
+function buildConversationTree(messages2) {
+  const messageMap = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const message of messages2) {
+    if (!message.uuid) continue;
+    const node = {
+      message,
+      children: []
+    };
+    messageMap.set(message.uuid, node);
+  }
+  for (const message of messages2) {
+    if (!message.uuid) continue;
+    const node = messageMap.get(message.uuid);
+    if (!node) continue;
+    if (!message.parentUuid) {
+      roots.push(node);
+    } else {
+      const parent = messageMap.get(message.parentUuid);
+      if (parent) {
+        parent.children.push(node);
+      } else {
+        roots.push(node);
+      }
+    }
+  }
+  return roots;
+}
+
+// src/claude/load-session.ts
+async function loadClaudeSession(sessionId, projectDir) {
+  const transcriptPath = getTranscriptPath(sessionId, projectDir);
+  const messages2 = await parseTranscript(transcriptPath);
+  const cwdMessage = messages2.find((msg) => msg.cwd);
+  const cwd = cwdMessage?.cwd || null;
+  return {
+    sessionId,
+    transcriptPath,
+    cwd,
+    messages: messages2
+  };
+}
+
+// src/db/index.ts
+var import_drizzle_orm14 = require("drizzle-orm");
+var import_bcryptjs2 = __toESM(require("bcryptjs"), 1);
+init_ids();
+
+// src/db/client.ts
+var import_client = require("@libsql/client");
+var import_libsql = require("drizzle-orm/libsql");
+
+// src/db/schema.ts
+var import_drizzle_orm = require("drizzle-orm");
+var import_sqlite_core = require("drizzle-orm/sqlite-core");
+var sessions = (0, import_sqlite_core.sqliteTable)(
+  "sessions",
+  {
+    // Primary identity
+    session_id: (0, import_sqlite_core.text)("session_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // User attribution
+    created_by: (0, import_sqlite_core.text)("created_by", { length: 36 }).notNull().default("anonymous"),
+    // Materialized for filtering/joins (cross-DB compatible)
+    status: (0, import_sqlite_core.text)("status", {
+      enum: ["idle", "running", "completed", "failed"]
+    }).notNull(),
+    agentic_tool: (0, import_sqlite_core.text)("agentic_tool", {
+      enum: ["claude-code", "cursor", "codex", "gemini"]
+    }).notNull(),
+    board_id: (0, import_sqlite_core.text)("board_id", { length: 36 }),
+    // NULL = no board
+    // Genealogy (materialized for tree queries)
+    parent_session_id: (0, import_sqlite_core.text)("parent_session_id", { length: 36 }),
+    forked_from_session_id: (0, import_sqlite_core.text)("forked_from_session_id", { length: 36 }),
+    // Worktree reference (REQUIRED: all sessions must have a worktree)
+    worktree_id: (0, import_sqlite_core.text)("worktree_id", { length: 36 }).notNull().references(() => worktrees.worktree_id, {
+      onDelete: "cascade"
+      // Cascade delete sessions when worktree is deleted
+    }),
+    // JSON blob for everything else (cross-DB via json() type)
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    statusIdx: (0, import_sqlite_core.index)("sessions_status_idx").on(table.status),
+    agenticToolIdx: (0, import_sqlite_core.index)("sessions_agentic_tool_idx").on(table.agentic_tool),
+    boardIdx: (0, import_sqlite_core.index)("sessions_board_idx").on(table.board_id),
+    worktreeIdx: (0, import_sqlite_core.index)("sessions_worktree_idx").on(table.worktree_id),
+    createdIdx: (0, import_sqlite_core.index)("sessions_created_idx").on(table.created_at),
+    parentIdx: (0, import_sqlite_core.index)("sessions_parent_idx").on(table.parent_session_id),
+    forkedIdx: (0, import_sqlite_core.index)("sessions_forked_idx").on(table.forked_from_session_id)
+  })
+);
+var tasks = (0, import_sqlite_core.sqliteTable)(
+  "tasks",
+  {
+    task_id: (0, import_sqlite_core.text)("task_id", { length: 36 }).primaryKey(),
+    session_id: (0, import_sqlite_core.text)("session_id", { length: 36 }).notNull().references(() => sessions.session_id, { onDelete: "cascade" }),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    completed_at: (0, import_sqlite_core.integer)("completed_at", { mode: "timestamp_ms" }),
+    status: (0, import_sqlite_core.text)("status", {
+      enum: [
+        "created",
+        "running",
+        "stopping",
+        "awaiting_permission",
+        "completed",
+        "failed",
+        "stopped"
+      ]
+    }).notNull(),
+    // User attribution
+    created_by: (0, import_sqlite_core.text)("created_by", { length: 36 }).notNull().default("anonymous"),
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    sessionIdx: (0, import_sqlite_core.index)("tasks_session_idx").on(table.session_id),
+    statusIdx: (0, import_sqlite_core.index)("tasks_status_idx").on(table.status),
+    createdIdx: (0, import_sqlite_core.index)("tasks_created_idx").on(table.created_at)
+  })
+);
+var messages = (0, import_sqlite_core.sqliteTable)(
+  "messages",
+  {
+    // Primary identity
+    message_id: (0, import_sqlite_core.text)("message_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    // Foreign keys (materialized for indexes)
+    session_id: (0, import_sqlite_core.text)("session_id", { length: 36 }).notNull().references(() => sessions.session_id, { onDelete: "cascade" }),
+    task_id: (0, import_sqlite_core.text)("task_id", { length: 36 }).references(() => tasks.task_id, {
+      onDelete: "set null"
+    }),
+    // Materialized for queries
+    type: (0, import_sqlite_core.text)("type", {
+      enum: ["user", "assistant", "system", "file-history-snapshot", "permission_request"]
+    }).notNull(),
+    role: (0, import_sqlite_core.text)("role", {
+      enum: ["user", "assistant", "system"]
+    }).notNull(),
+    index: (0, import_sqlite_core.integer)("index").notNull(),
+    // Position in conversation (0-based)
+    timestamp: (0, import_sqlite_core.integer)("timestamp", { mode: "timestamp_ms" }).notNull(),
+    content_preview: (0, import_sqlite_core.text)("content_preview"),
+    // First 200 chars for list views
+    // Full data (JSON blob)
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    // Indexes for efficient lookups
+    sessionIdx: (0, import_sqlite_core.index)("messages_session_id_idx").on(table.session_id),
+    taskIdx: (0, import_sqlite_core.index)("messages_task_id_idx").on(table.task_id),
+    sessionIndexIdx: (0, import_sqlite_core.index)("messages_session_index_idx").on(table.session_id, table.index)
+  })
+);
+var boards = (0, import_sqlite_core.sqliteTable)(
+  "boards",
+  {
+    board_id: (0, import_sqlite_core.text)("board_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // User attribution
+    created_by: (0, import_sqlite_core.text)("created_by", { length: 36 }).notNull().default("anonymous"),
+    // Materialized for lookups
+    name: (0, import_sqlite_core.text)("name").notNull(),
+    slug: (0, import_sqlite_core.text)("slug").unique(),
+    // JSON blob for the rest
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    nameIdx: (0, import_sqlite_core.index)("boards_name_idx").on(table.name),
+    slugIdx: (0, import_sqlite_core.index)("boards_slug_idx").on(table.slug)
+  })
+);
+var repos = (0, import_sqlite_core.sqliteTable)(
+  "repos",
+  {
+    repo_id: (0, import_sqlite_core.text)("repo_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // Materialized for querying
+    slug: (0, import_sqlite_core.text)("slug").notNull().unique(),
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    slugIdx: (0, import_sqlite_core.index)("repos_slug_idx").on(table.slug)
+  })
+);
+var worktrees = (0, import_sqlite_core.sqliteTable)(
+  "worktrees",
+  {
+    // Primary identity
+    worktree_id: (0, import_sqlite_core.text)("worktree_id", { length: 36 }).primaryKey(),
+    repo_id: (0, import_sqlite_core.text)("repo_id", { length: 36 }).notNull().references(() => repos.repo_id, { onDelete: "cascade" }),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // User attribution
+    created_by: (0, import_sqlite_core.text)("created_by", { length: 36 }).notNull().default("anonymous"),
+    // Materialized for queries
+    name: (0, import_sqlite_core.text)("name").notNull(),
+    // "feat-auth", "main"
+    ref: (0, import_sqlite_core.text)("ref").notNull(),
+    // Current branch/tag/commit
+    worktree_unique_id: (0, import_sqlite_core.integer)("worktree_unique_id").notNull(),
+    // Auto-assigned sequential ID for templates
+    // Board relationship (nullable - worktrees can exist without boards)
+    board_id: (0, import_sqlite_core.text)("board_id", { length: 36 }).references(() => boards.board_id, {
+      onDelete: "set null"
+      // If board is deleted, worktree remains but loses board association
+    }),
+    // JSON blob for everything else
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    repoIdx: (0, import_sqlite_core.index)("worktrees_repo_idx").on(table.repo_id),
+    nameIdx: (0, import_sqlite_core.index)("worktrees_name_idx").on(table.name),
+    refIdx: (0, import_sqlite_core.index)("worktrees_ref_idx").on(table.ref),
+    boardIdx: (0, import_sqlite_core.index)("worktrees_board_idx").on(table.board_id),
+    createdIdx: (0, import_sqlite_core.index)("worktrees_created_idx").on(table.created_at),
+    updatedIdx: (0, import_sqlite_core.index)("worktrees_updated_idx").on(table.updated_at),
+    // Composite unique constraint (repo + name)
+    uniqueRepoName: (0, import_sqlite_core.index)("worktrees_repo_name_unique").on(table.repo_id, table.name)
+  })
+);
+var users = (0, import_sqlite_core.sqliteTable)(
+  "users",
+  {
+    // Primary identity
+    user_id: (0, import_sqlite_core.text)("user_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // Materialized for auth lookups
+    email: (0, import_sqlite_core.text)("email").unique().notNull(),
+    password: (0, import_sqlite_core.text)("password").notNull(),
+    // bcrypt hashed
+    // Basic profile (materialized for display)
+    name: (0, import_sqlite_core.text)("name"),
+    emoji: (0, import_sqlite_core.text)("emoji"),
+    role: (0, import_sqlite_core.text)("role", {
+      enum: ["owner", "admin", "member", "viewer"]
+    }).notNull().default("member"),
+    // Onboarding state
+    onboarding_completed: (0, import_sqlite_core.integer)("onboarding_completed", { mode: "boolean" }).notNull().default(false),
+    // JSON blob for profile/preferences
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    emailIdx: (0, import_sqlite_core.index)("users_email_idx").on(table.email)
+  })
+);
+var mcpServers = (0, import_sqlite_core.sqliteTable)(
+  "mcp_servers",
+  {
+    // Primary identity
+    mcp_server_id: (0, import_sqlite_core.text)("mcp_server_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // Materialized for filtering
+    name: (0, import_sqlite_core.text)("name").notNull(),
+    // e.g., "filesystem", "sentry"
+    transport: (0, import_sqlite_core.text)("transport", {
+      enum: ["stdio", "http", "sse"]
+    }).notNull(),
+    scope: (0, import_sqlite_core.text)("scope", {
+      enum: ["global", "team", "repo", "session"]
+    }).notNull(),
+    enabled: (0, import_sqlite_core.integer)("enabled", { mode: "boolean" }).notNull().default(true),
+    // Scope foreign keys (materialized for indexes)
+    owner_user_id: (0, import_sqlite_core.text)("owner_user_id", { length: 36 }),
+    team_id: (0, import_sqlite_core.text)("team_id", { length: 36 }),
+    repo_id: (0, import_sqlite_core.text)("repo_id", { length: 36 }).references(() => repos.repo_id, {
+      onDelete: "cascade"
+    }),
+    session_id: (0, import_sqlite_core.text)("session_id", { length: 36 }).references(() => sessions.session_id, {
+      onDelete: "cascade"
+    }),
+    // Source tracking (materialized for queries)
+    source: (0, import_sqlite_core.text)("source", {
+      enum: ["user", "imported", "agor"]
+    }).notNull(),
+    // JSON blob for configuration and capabilities
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    nameIdx: (0, import_sqlite_core.index)("mcp_servers_name_idx").on(table.name),
+    scopeIdx: (0, import_sqlite_core.index)("mcp_servers_scope_idx").on(table.scope),
+    ownerIdx: (0, import_sqlite_core.index)("mcp_servers_owner_idx").on(table.owner_user_id),
+    teamIdx: (0, import_sqlite_core.index)("mcp_servers_team_idx").on(table.team_id),
+    repoIdx: (0, import_sqlite_core.index)("mcp_servers_repo_idx").on(table.repo_id),
+    sessionIdx: (0, import_sqlite_core.index)("mcp_servers_session_idx").on(table.session_id),
+    enabledIdx: (0, import_sqlite_core.index)("mcp_servers_enabled_idx").on(table.enabled)
+  })
+);
+var boardObjects = (0, import_sqlite_core.sqliteTable)(
+  "board_objects",
+  {
+    // Primary identity
+    object_id: (0, import_sqlite_core.text)("object_id", { length: 36 }).primaryKey(),
+    board_id: (0, import_sqlite_core.text)("board_id", { length: 36 }).notNull().references(() => boards.board_id, { onDelete: "cascade" }),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    // Worktree reference
+    worktree_id: (0, import_sqlite_core.text)("worktree_id", { length: 36 }).notNull().references(() => worktrees.worktree_id, {
+      onDelete: "cascade"
+    }),
+    // Position data (JSON)
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    boardIdx: (0, import_sqlite_core.index)("board_objects_board_idx").on(table.board_id),
+    worktreeIdx: (0, import_sqlite_core.index)("board_objects_worktree_idx").on(table.worktree_id)
+  })
+);
+var sessionMcpServers = (0, import_sqlite_core.sqliteTable)(
+  "session_mcp_servers",
+  {
+    session_id: (0, import_sqlite_core.text)("session_id", { length: 36 }).notNull().references(() => sessions.session_id, { onDelete: "cascade" }),
+    mcp_server_id: (0, import_sqlite_core.text)("mcp_server_id", { length: 36 }).notNull().references(() => mcpServers.mcp_server_id, { onDelete: "cascade" }),
+    enabled: (0, import_sqlite_core.integer)("enabled", { mode: "boolean" }).notNull().default(true),
+    added_at: (0, import_sqlite_core.integer)("added_at", { mode: "timestamp_ms" }).notNull()
+  },
+  (table) => ({
+    // Composite primary key
+    pk: (0, import_sqlite_core.index)("session_mcp_servers_pk").on(table.session_id, table.mcp_server_id),
+    // Indexes for queries
+    sessionIdx: (0, import_sqlite_core.index)("session_mcp_servers_session_idx").on(table.session_id),
+    serverIdx: (0, import_sqlite_core.index)("session_mcp_servers_server_idx").on(table.mcp_server_id),
+    enabledIdx: (0, import_sqlite_core.index)("session_mcp_servers_enabled_idx").on(table.session_id, table.enabled)
+  })
+);
+var boardComments = (0, import_sqlite_core.sqliteTable)(
+  "board_comments",
+  {
+    // Primary identity
+    comment_id: (0, import_sqlite_core.text)("comment_id", { length: 36 }).primaryKey(),
+    created_at: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+    updated_at: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }),
+    // Scoping & authorship
+    board_id: (0, import_sqlite_core.text)("board_id", { length: 36 }).notNull().references(() => boards.board_id, { onDelete: "cascade" }),
+    created_by: (0, import_sqlite_core.text)("created_by", { length: 36 }).notNull().default("anonymous"),
+    // FLEXIBLE ATTACHMENTS (all optional)
+    // Phase 1: board-level only (all NULL)
+    // Phase 2: object attachments (session, task, message, worktree)
+    // Phase 3: spatial positioning
+    session_id: (0, import_sqlite_core.text)("session_id", { length: 36 }).references(() => sessions.session_id, {
+      onDelete: "set null"
+    }),
+    task_id: (0, import_sqlite_core.text)("task_id", { length: 36 }).references(() => tasks.task_id, {
+      onDelete: "set null"
+    }),
+    message_id: (0, import_sqlite_core.text)("message_id", { length: 36 }).references(() => messages.message_id, {
+      onDelete: "set null"
+    }),
+    worktree_id: (0, import_sqlite_core.text)("worktree_id", { length: 36 }).references(() => worktrees.worktree_id, {
+      onDelete: "set null"
+    }),
+    // Content (materialized for display)
+    content: (0, import_sqlite_core.text)("content").notNull(),
+    // Markdown-supported text
+    content_preview: (0, import_sqlite_core.text)("content_preview").notNull(),
+    // First 200 chars
+    // Thread support (optional)
+    parent_comment_id: (0, import_sqlite_core.text)("parent_comment_id", { length: 36 }),
+    // Metadata (materialized for filtering)
+    resolved: (0, import_sqlite_core.integer)("resolved", { mode: "boolean" }).notNull().default(false),
+    edited: (0, import_sqlite_core.integer)("edited", { mode: "boolean" }).notNull().default(false),
+    // Reactions (for BOTH thread roots and replies)
+    // Stored as JSON array: [{ user_id: "abc", emoji: "👍" }, ...]
+    // Display grouped by emoji: { "👍": ["alice", "bob"], "🎉": ["charlie"] }
+    reactions: (0, import_sqlite_core.text)("reactions", { mode: "json" }).$type().notNull().default(import_drizzle_orm.sql`'[]'`),
+    // JSON blob for advanced features
+    data: (0, import_sqlite_core.text)("data", { mode: "json" }).$type().notNull()
+  },
+  (table) => ({
+    boardIdx: (0, import_sqlite_core.index)("board_comments_board_idx").on(table.board_id),
+    sessionIdx: (0, import_sqlite_core.index)("board_comments_session_idx").on(table.session_id),
+    taskIdx: (0, import_sqlite_core.index)("board_comments_task_idx").on(table.task_id),
+    messageIdx: (0, import_sqlite_core.index)("board_comments_message_idx").on(table.message_id),
+    worktreeIdx: (0, import_sqlite_core.index)("board_comments_worktree_idx").on(table.worktree_id),
+    createdByIdx: (0, import_sqlite_core.index)("board_comments_created_by_idx").on(table.created_by),
+    parentIdx: (0, import_sqlite_core.index)("board_comments_parent_idx").on(table.parent_comment_id),
+    createdIdx: (0, import_sqlite_core.index)("board_comments_created_idx").on(table.created_at),
+    resolvedIdx: (0, import_sqlite_core.index)("board_comments_resolved_idx").on(table.resolved)
+  })
+);
+
+// src/db/migrate.ts
+var import_drizzle_orm2 = require("drizzle-orm");
+var import_migrator = require("drizzle-orm/libsql/migrator");
+
+// src/db/repositories/board-comments.ts
+var import_drizzle_orm3 = require("drizzle-orm");
+init_ids();
+
+// src/db/repositories/board-objects.ts
+var import_drizzle_orm4 = require("drizzle-orm");
+init_ids();
+
+// src/db/repositories/boards.ts
+var import_drizzle_orm5 = require("drizzle-orm");
+init_ids();
+
+// src/db/repositories/mcp-servers.ts
+var import_drizzle_orm6 = require("drizzle-orm");
+init_ids();
+
+// src/db/repositories/messages.ts
+var import_drizzle_orm7 = require("drizzle-orm");
+
+// src/db/repositories/repos.ts
+var import_drizzle_orm8 = require("drizzle-orm");
+init_ids();
+
+// src/db/repositories/session-mcp-servers.ts
+var import_drizzle_orm10 = require("drizzle-orm");
+
+// src/types/task.ts
+var TaskStatus = {
+  CREATED: "created",
+  RUNNING: "running",
+  STOPPING: "stopping",
+  // Stop requested, waiting for SDK to halt
+  AWAITING_PERMISSION: "awaiting_permission",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  STOPPED: "stopped"
+  // User-requested stop (distinct from failed)
+};
+
+// src/db/repositories/sessions.ts
+var import_drizzle_orm9 = require("drizzle-orm");
+init_ids();
+
+// src/db/repositories/tasks.ts
+var import_drizzle_orm11 = require("drizzle-orm");
+init_ids();
+
+// src/db/repositories/worktrees.ts
+var import_drizzle_orm12 = require("drizzle-orm");
+init_ids();
+
+// src/db/user-utils.ts
+var import_bcryptjs = __toESM(require("bcryptjs"), 1);
+var import_drizzle_orm13 = require("drizzle-orm");
+init_ids();
+
+// src/db/index.ts
+var compare = import_bcryptjs2.default.compare;
+var hash = import_bcryptjs2.default.hash;
+
+// src/claude/message-converter.ts
+function transcriptToMessage(transcript, sessionId, index2) {
+  const content = transcript.message?.content || "";
+  const contentPreview = typeof content === "string" ? content.substring(0, 200) : JSON.stringify(content).substring(0, 200);
+  const role = transcript.message?.role || transcript.type;
+  let toolUses;
+  if (Array.isArray(content)) {
+    const tools = content.filter((c) => c.type === "tool_use");
+    if (tools.length > 0) {
+      toolUses = tools.map((tool) => ({
+        id: tool.id,
+        name: tool.name,
+        input: tool.input || {}
+      }));
+    }
+  }
+  return {
+    message_id: generateId(),
+    session_id: sessionId,
+    type: transcript.type,
+    role,
+    index: index2,
+    timestamp: transcript.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    content_preview: contentPreview,
+    content,
+    tool_uses: toolUses,
+    metadata: {
+      original_id: transcript.uuid,
+      parent_id: transcript.parentUuid || void 0,
+      is_meta: transcript.isMeta
+    }
+  };
+}
+function transcriptsToMessages(transcripts, sessionId) {
+  return transcripts.map((transcript, index2) => transcriptToMessage(transcript, sessionId, index2));
+}
+
+// src/claude/task-extractor.ts
+init_ids();
+function extractTasksFromMessages(messages2, sessionId) {
+  const tasks2 = [];
+  const userMessageIndices = messages2.map((msg, idx) => msg.type === "user" ? idx : -1).filter((idx) => idx !== -1);
+  for (let i = 0; i < userMessageIndices.length; i++) {
+    const startIndex = userMessageIndices[i];
+    const userMessage = messages2[startIndex];
+    const endIndex = i < userMessageIndices.length - 1 ? userMessageIndices[i + 1] - 1 : messages2.length - 1;
+    const messagesInRange = messages2.slice(startIndex, endIndex + 1);
+    const toolUseCount = messagesInRange.reduce((count, msg) => {
+      return count + (msg.tool_uses?.length ?? 0);
+    }, 0);
+    let fullPrompt = "";
+    if (typeof userMessage.content === "string") {
+      fullPrompt = userMessage.content;
+    } else if (Array.isArray(userMessage.content)) {
+      const textContent = userMessage.content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
+      fullPrompt = textContent || JSON.stringify(userMessage.content);
+    } else {
+      fullPrompt = JSON.stringify(userMessage.content);
+    }
+    const cleanPrompt = fullPrompt.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+    const description = cleanPrompt.substring(0, 120) + (cleanPrompt.length > 120 ? "..." : "");
+    const startTimestamp = userMessage.timestamp;
+    const endMessage = messages2[endIndex];
+    const endTimestamp = endMessage?.timestamp;
+    tasks2.push({
+      task_id: generateId(),
+      session_id: sessionId,
+      full_prompt: fullPrompt,
+      description,
+      status: TaskStatus.COMPLETED,
+      // Imported sessions are historical
+      message_range: {
+        start_index: startIndex,
+        end_index: endIndex,
+        start_timestamp: startTimestamp,
+        end_timestamp: endTimestamp
+      },
+      git_state: {
+        ref_at_start: "unknown",
+        // No git tracking in Claude Code transcripts
+        sha_at_start: "unknown"
+        // No git tracking in Claude Code transcripts
+      },
+      model: userMessage.metadata?.model || "claude-sonnet-4-5",
+      tool_use_count: toolUseCount,
+      created_at: startTimestamp,
+      completed_at: endTimestamp
+    });
+  }
+  return tasks2;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildConversationTree,
+  extractTasksFromMessages,
+  filterConversationMessages,
+  getTranscriptPath,
+  loadClaudeSession,
+  loadSessionTranscript,
+  parseTranscript,
+  transcriptToMessage,
+  transcriptsToMessages
+});