agor-live 0.3.7

package/dist/core/dist/db/index.d.cts

@@ -0,0 +1,631 @@
+export { and, desc, eq, inArray, like, or, sql } from 'drizzle-orm';
+import bcryptjs from 'bcryptjs';
+import { b as Database, B as BaseRepository } from '../worktrees-BzIxB1U6.cjs';
+export { A as AmbiguousIdError, Q as BoardCommentInsert, P as BoardCommentRow, y as BoardInsert, O as BoardObjectInsert, N as BoardObjectRow, x as BoardRow, d as DEFAULT_DB_PATH, a as DatabaseConnectionError, D as DbConfig, E as EntityNotFoundError, J as MCPServerInsert, M as MCPServerRepository, I as MCPServerRow, v as MessageInsert, q as MessageRow, f as MessagesRepository, C as RepoInsert, z as RepoRow, R as RepositoryError, o as SessionInsert, L as SessionMCPServerInsert, S as SessionMCPServerRepository, K as SessionMCPServerRow, g as SessionRepository, n as SessionRow, p as TaskInsert, T as TaskRow, H as UserInsert, U as UserRow, G as WorktreeInsert, W as WorktreeRepository, F as WorktreeRow, l as boardComments, j as boardObjects, h as boards, c as createDatabase, e as createLocalDatabase, i as mcpServers, m as messages, r as repos, k as sessionMcpServers, s as sessions, t as tasks, u as users, w as worktrees } from '../worktrees-BzIxB1U6.cjs';
+import { B as BoardComment } from '../board-comment-BUm0fpmD.cjs';
+import { B as BoardID, W as WorktreeID } from '../id-DMqyogFB.cjs';
+import { b as BoardEntityObject, f as Board, e as BoardObject } from '../session-BPjJlVdZ.cjs';
+import { a as Repo } from '../repo-3CUrCRbq.cjs';
+import { e as Task } from '../task-BIEgT1DK.cjs';
+import { a as User } from '../user-eUuKj7yM.cjs';
+import '../message-BoxZISHg.cjs';
+import 'drizzle-orm/libsql';
+import 'drizzle-orm/sqlite-core';
+import '../agentic-tool-DsyX8diw.cjs';
+
+/**
+ * ID Management Utilities
+ *
+ * Agor uses UUIDv7 for all entity identifiers.
+ * This module provides generation, validation, and resolution utilities.
+ *
+ * Key concepts:
+ * - Full UUIDs stored in database (36 chars)
+ * - Short IDs displayed to users (8-16 chars)
+ * - Git-style collision resolution (expand prefix when ambiguous)
+ *
+ * @see context/concepts/id-management.md
+ */
+/**
+ * UUIDv7 identifier (36 characters including hyphens)
+ *
+ * Format: 01933e4a-7b89-7c35-a8f3-9d2e1c4b5a6f
+ * - First 48 bits: Unix timestamp (ms)
+ * - Next 12 bits: Random sequence
+ * - Last 62 bits: Random data
+ */
+type UUID = string & {
+    readonly __brand: 'UUID';
+};
+/**
+ * Short ID prefix (8-16 characters, no hyphens)
+ *
+ * Used for display and user input.
+ * Example: "01933e4a" (8 chars) or "01933e4a7b89" (12 chars)
+ */
+type ShortID = string;
+/**
+ * Any length ID prefix for matching
+ */
+type IDPrefix = string;
+/**
+ * Generate a new UUIDv7 identifier.
+ *
+ * UUIDv7 provides:
+ * - Global uniqueness (2^122 possible values)
+ * - Time-ordered (sortable by creation time)
+ * - Excellent database index performance
+ *
+ * @returns A new UUIDv7 string
+ *
+ * @example
+ * const sessionId = generateId();
+ * // => "01933e4a-7b89-7c35-a8f3-9d2e1c4b5a6f"
+ */
+declare function generateId(): UUID;
+/**
+ * Format short ID for display (alias for shortId for backward compatibility)
+ *
+ * @deprecated Use shortId() instead
+ */
+declare function formatShortId(uuid: UUID, length?: number): ShortID;
+/**
+ * Error thrown when short ID resolution fails
+ */
+declare class IdResolutionError extends Error {
+    readonly type: 'not_found' | 'ambiguous';
+    readonly prefix?: string | undefined;
+    readonly candidates?: Array<{
+        id: string;
+        label?: string;
+    }> | undefined;
+    constructor(message: string, type: 'not_found' | 'ambiguous', prefix?: string | undefined, candidates?: Array<{
+        id: string;
+        label?: string;
+    }> | undefined);
+}
+/**
+ * Resolve a short ID prefix to a full entity.
+ *
+ * This implements git-style ID resolution:
+ * - If exactly one match: return it
+ * - If no matches: throw error
+ * - If multiple matches: throw error with suggestions
+ *
+ * @param prefix - Short ID or partial UUID
+ * @param entities - Array of entities to search
+ * @returns Matching entity
+ * @throws IdResolutionError if not found or ambiguous
+ *
+ * @example
+ * const sessions = [
+ *   { id: "01933e4a-7b89-7c35-a8f3-9d2e1c4b5a6f", description: "Auth" },
+ *   { id: "01934c2d-1234-7c35-a8f3-9d2e1c4b5a6f", description: "CORS" },
+ * ];
+ *
+ * resolveShortId("01933e4a", sessions)
+ * // => { id: "01933e4a-...", description: "Auth" }
+ *
+ * resolveShortId("0193", sessions)
+ * // => Error: Ambiguous ID prefix
+ */
+declare function resolveShortId<T extends {
+    id: UUID;
+}>(prefix: IDPrefix, entities: T[]): T;
+
+/**
+ * Database Migration Runner
+ *
+ * DEPRECATED: This file contains manual SQL schema creation and is kept for backwards compatibility.
+ *
+ * **New Approach (Recommended):**
+ * Use `drizzle-kit push` to automatically sync schema.ts to database:
+ *   - Run: `pnpm db:push` from packages/core
+ *   - Drizzle Kit reads schema.ts and generates SQL automatically
+ *   - No need to maintain manual CREATE TABLE statements
+ *   - Single source of truth: packages/core/src/db/schema.ts
+ *
+ * **This file is still used by:**
+ * - setup-db.ts for programmatic database initialization
+ * - Legacy code that calls initializeDatabase() directly
+ *
+ * **Migration Path:**
+ * For fresh databases: Use `pnpm db:push`
+ * For existing databases: Use `pnpm db:push` (will detect and apply schema changes)
+ * For seed data: Still use seedInitialData() from this file
+ */
+
+/**
+ * Error thrown when migration fails
+ */
+declare class MigrationError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+/**
+ * Run database migrations
+ *
+ * @param db Drizzle database instance
+ * @param migrationsFolder Path to migrations folder (default: './migrations')
+ *
+ * @example
+ * ```typescript
+ * import { createDatabase } from './client';
+ * import { runMigrations } from './migrate';
+ *
+ * const db = createDatabase({ url: 'file:~/.agor/sessions.db' });
+ * await runMigrations(db);
+ * ```
+ */
+declare function runMigrations(db: Database, migrationsFolder?: string): Promise<void>;
+/**
+ * Initialize database (create schema if needed)
+ *
+ * Simpler alternative to runMigrations when you don't have migration files.
+ * Always safe to call - creates tables only if they don't exist.
+ *
+ * INCREMENTAL MIGRATION SUPPORT:
+ * This function now checks for each table individually and adds missing ones.
+ * Safe to call on existing databases - only adds what's missing.
+ */
+declare function initializeDatabase(db: Database): Promise<void>;
+/**
+ * Seed initial data (default board)
+ */
+declare function seedInitialData(db: Database): Promise<void>;
+
+/**
+ * Board Comments Repository
+ *
+ * Type-safe CRUD operations for board comments with short ID support.
+ * Supports flexible attachments (board, session, task, message, worktree, spatial).
+ */
+
+/**
+ * Board comments repository implementation
+ */
+declare class BoardCommentsRepository implements BaseRepository<BoardComment, Partial<BoardComment>> {
+    private db;
+    constructor(db: Database);
+    /**
+     * Convert database row to BoardComment type
+     */
+    private rowToComment;
+    /**
+     * Convert BoardComment to database insert format
+     */
+    private commentToInsert;
+    /**
+     * Resolve short ID to full ID
+     */
+    private resolveId;
+    /**
+     * Create a new comment
+     */
+    create(data: Partial<BoardComment>): Promise<BoardComment>;
+    /**
+     * Find comment by ID (supports short ID)
+     */
+    findById(id: string): Promise<BoardComment | null>;
+    /**
+     * Find all comments (optionally filtered by board, session, task, etc.)
+     */
+    findAll(filters?: {
+        board_id?: string;
+        session_id?: string;
+        task_id?: string;
+        message_id?: string;
+        worktree_id?: string;
+        resolved?: boolean;
+        created_by?: string;
+    }): Promise<BoardComment[]>;
+    /**
+     * Update comment by ID
+     */
+    update(id: string, updates: Partial<BoardComment>): Promise<BoardComment>;
+    /**
+     * Delete comment by ID
+     * If deleting a thread root, also deletes all replies (cascade)
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Resolve comment (mark as resolved)
+     */
+    resolve(id: string): Promise<BoardComment>;
+    /**
+     * Unresolve comment (mark as unresolved)
+     */
+    unresolve(id: string): Promise<BoardComment>;
+    /**
+     * Find comments by board ID with optional filters
+     */
+    findByBoard(boardId: string, filters?: {
+        resolved?: boolean;
+        created_by?: string;
+        session_id?: string;
+    }): Promise<BoardComment[]>;
+    /**
+     * Find comments for a specific session
+     */
+    findBySession(sessionId: string): Promise<BoardComment[]>;
+    /**
+     * Find comments for a specific task
+     */
+    findByTask(taskId: string): Promise<BoardComment[]>;
+    /**
+     * Find comments mentioning a specific user
+     */
+    findMentions(userId: string, boardId?: string): Promise<BoardComment[]>;
+    /**
+     * Batch create comments (for bulk operations)
+     */
+    bulkCreate(comments: Partial<BoardComment>[]): Promise<BoardComment[]>;
+    /**
+     * Toggle a reaction on a comment
+     * If user has already reacted with this emoji, remove it. Otherwise, add it.
+     */
+    toggleReaction(commentId: string, userId: string, emoji: string): Promise<BoardComment>;
+    /**
+     * Create a reply to a comment (thread root)
+     * Validates that parent exists and is a thread root
+     */
+    createReply(parentId: string, data: Partial<BoardComment>): Promise<BoardComment>;
+}
+
+/**
+ * Board Objects Repository
+ *
+ * Manages positioned entities (sessions and worktrees) on boards.
+ * Phase 1: Hybrid support for both session cards and worktree cards.
+ */
+
+/**
+ * Board object repository implementation
+ */
+declare class BoardObjectRepository {
+    private db;
+    constructor(db: Database);
+    /**
+     * Find all board objects
+     */
+    findAll(): Promise<BoardEntityObject[]>;
+    /**
+     * Find all board objects for a board
+     */
+    findByBoardId(boardId: BoardID): Promise<BoardEntityObject[]>;
+    /**
+     * Find board object by object ID
+     */
+    findByObjectId(objectId: string): Promise<BoardEntityObject | null>;
+    /**
+     * Find board object by worktree ID
+     */
+    findByWorktreeId(worktreeId: WorktreeID): Promise<BoardEntityObject | null>;
+    /**
+     * Create a board object (add worktree to board)
+     */
+    create(data: {
+        board_id: BoardID;
+        worktree_id: WorktreeID;
+        position: {
+            x: number;
+            y: number;
+        };
+        zone_id?: string;
+    }): Promise<BoardEntityObject>;
+    /**
+     * Update position of board object (preserves zone_id)
+     */
+    updatePosition(objectId: string, position: {
+        x: number;
+        y: number;
+    }): Promise<BoardEntityObject>;
+    /**
+     * Update zone pinning for board object
+     */
+    updateZone(objectId: string, zoneId: string | undefined | null): Promise<BoardEntityObject>;
+    /**
+     * Remove board object (remove entity from board)
+     */
+    remove(objectId: string): Promise<void>;
+    /**
+     * Remove all board objects for a worktree
+     */
+    removeByWorktreeId(worktreeId: WorktreeID): Promise<void>;
+    /**
+     * Convert database row to entity
+     */
+    private rowToEntity;
+}
+
+/**
+ * Board Repository
+ *
+ * Type-safe CRUD operations for boards with short ID support.
+ */
+
+/**
+ * Board repository implementation
+ */
+declare class BoardRepository implements BaseRepository<Board, Partial<Board>> {
+    private db;
+    constructor(db: Database);
+    /**
+     * Convert database row to Board type
+     */
+    private rowToBoard;
+    /**
+     * Convert Board to database insert format
+     */
+    private boardToInsert;
+    /**
+     * Resolve short ID to full ID
+     */
+    private resolveId;
+    /**
+     * Create a new board
+     */
+    create(data: Partial<Board>): Promise<Board>;
+    /**
+     * Find board by ID (supports short ID)
+     */
+    findById(id: string): Promise<Board | null>;
+    /**
+     * Find board by slug
+     */
+    findBySlug(slug: string): Promise<Board | null>;
+    /**
+     * Find all boards
+     */
+    findAll(): Promise<Board[]>;
+    /**
+     * Update board by ID
+     */
+    update(id: string, updates: Partial<Board>): Promise<Board>;
+    /**
+     * Delete board by ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * DEPRECATED: Add session to board
+     * Use board-objects service instead
+     */
+    /**
+     * DEPRECATED: Remove session from board
+     * Use board-objects service instead
+     */
+    /**
+     * Get default board (or create if doesn't exist)
+     */
+    getDefault(): Promise<Board>;
+    /**
+     * Atomically add or update a board object (text label or zone)
+     *
+     * Uses read-modify-write approach with proper serialization via update() method.
+     */
+    upsertBoardObject(boardId: string, objectId: string, objectData: BoardObject): Promise<Board>;
+    /**
+     * Atomically remove a board object
+     */
+    removeBoardObject(boardId: string, objectId: string): Promise<Board>;
+    /**
+     * Batch upsert multiple objects (sequential atomic updates)
+     *
+     * Note: Not a single transaction - each object is updated atomically.
+     * This is safe for independent objects but may have partial failures.
+     */
+    batchUpsertBoardObjects(boardId: string, objects: Record<string, BoardObject>): Promise<Board>;
+    /**
+     * DEPRECATED: Delete a zone and handle associated sessions
+     * TODO: Reimplement using board-objects table
+     */
+    deleteZone(boardId: string, objectId: string, _deleteAssociatedSessions: boolean): Promise<{
+        board: Board;
+        affectedSessions: string[];
+    }>;
+}
+
+/**
+ * Repo Repository
+ *
+ * Type-safe CRUD operations for git repositories with short ID support.
+ */
+
+/**
+ * Repo repository implementation
+ */
+declare class RepoRepository implements BaseRepository<Repo, Partial<Repo>> {
+    private db;
+    constructor(db: Database);
+    /**
+     * Convert database row to Repo type
+     */
+    private rowToRepo;
+    /**
+     * Convert Repo to database insert format
+     */
+    private repoToInsert;
+    /**
+     * Resolve short ID to full ID
+     */
+    private resolveId;
+    /**
+     * Create a new repo
+     */
+    create(data: Partial<Repo>): Promise<Repo>;
+    /**
+     * Find repo by ID (supports short ID)
+     */
+    findById(id: string): Promise<Repo | null>;
+    /**
+     * Find repo by slug (exact match)
+     */
+    findBySlug(slug: string): Promise<Repo | null>;
+    /**
+     * Find all repos
+     */
+    findAll(): Promise<Repo[]>;
+    /**
+     * Find managed repos only (DEPRECATED: all repos are managed now)
+     *
+     * Kept for backwards compatibility - returns all repos.
+     */
+    findManaged(): Promise<Repo[]>;
+    /**
+     * Update repo by ID
+     */
+    update(id: string, updates: Partial<Repo>): Promise<Repo>;
+    /**
+     * Delete repo by ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * @deprecated Worktrees are now first-class entities in their own table.
+     * Use WorktreeRepository instead.
+     */
+    addWorktree(): Promise<never>;
+    /**
+     * @deprecated Worktrees are now first-class entities in their own table.
+     * Use WorktreeRepository instead.
+     */
+    removeWorktree(): Promise<never>;
+    /**
+     * Count total repos
+     */
+    count(): Promise<number>;
+}
+
+/**
+ * Task Repository
+ *
+ * Type-safe CRUD operations for tasks with short ID support.
+ */
+
+/**
+ * Task repository implementation
+ */
+declare class TaskRepository implements BaseRepository<Task, Partial<Task>> {
+    private db;
+    constructor(db: Database);
+    /**
+     * Convert database row to Task type
+     */
+    private rowToTask;
+    /**
+     * Convert Task to database insert format
+     */
+    private taskToInsert;
+    /**
+     * Resolve short ID to full ID
+     */
+    private resolveId;
+    /**
+     * Create a new task
+     */
+    create(data: Partial<Task>): Promise<Task>;
+    /**
+     * Bulk create multiple tasks (for imports)
+     */
+    createMany(taskList: Partial<Task>[]): Promise<Task[]>;
+    /**
+     * Find task by ID (supports short ID)
+     */
+    findById(id: string): Promise<Task | null>;
+    /**
+     * Find all tasks
+     */
+    findAll(): Promise<Task[]>;
+    /**
+     * Find all tasks for a session
+     */
+    findBySession(sessionId: string): Promise<Task[]>;
+    /**
+     * Find running tasks across all sessions
+     */
+    findRunning(): Promise<Task[]>;
+    /**
+     * Find tasks by status
+     */
+    findByStatus(status: Task['status']): Promise<Task[]>;
+    /**
+     * Update task by ID
+     */
+    update(id: string, updates: Partial<Task>): Promise<Task>;
+    /**
+     * Delete task by ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Count tasks for a session
+     */
+    countBySession(sessionId: string): Promise<number>;
+}
+
+/**
+ * User utility functions
+ *
+ * Shared logic for creating and managing users without requiring daemon.
+ */
+
+/**
+ * Create user input
+ */
+interface CreateUserData {
+    email: string;
+    password: string;
+    name?: string;
+    role?: 'owner' | 'admin' | 'member' | 'viewer';
+}
+/**
+ * Create a new user directly in the database
+ *
+ * This is a standalone utility that can be used by both CLI and daemon.
+ * It doesn't require the daemon to be running.
+ *
+ * @param db - Database instance
+ * @param data - User data
+ * @returns Created user
+ */
+declare function createUser(db: Database, data: CreateUserData): Promise<User>;
+/**
+ * Check if a user with the given email exists
+ *
+ * @param db - Database instance
+ * @param email - Email to check
+ * @returns True if user exists
+ */
+declare function userExists(db: Database, email: string): Promise<boolean>;
+/**
+ * Get user by email
+ *
+ * @param db - Database instance
+ * @param email - Email to look up
+ * @returns User or null if not found
+ */
+declare function getUserByEmail(db: Database, email: string): Promise<User | null>;
+/**
+ * Default admin user credentials
+ * Used by both init and user create-admin commands
+ */
+declare const DEFAULT_ADMIN_USER: {
+    email: string;
+    password: string;
+    name: string;
+    role: "admin";
+};
+/**
+ * Create default admin user (admin@agor.live / admin)
+ *
+ * This is a convenience function for creating the default admin user
+ * with hardcoded credentials. Use createUser() if you need custom credentials.
+ *
+ * @param db - Database instance
+ * @returns Created user
+ * @throws Error if admin user already exists
+ */
+declare function createDefaultAdminUser(db: Database): Promise<User>;
+
+declare const compare: typeof bcryptjs.compare;
+declare const hash: typeof bcryptjs.hash;
+
+export { BaseRepository, BoardCommentsRepository, BoardObjectRepository, BoardRepository, type CreateUserData, DEFAULT_ADMIN_USER, Database, IdResolutionError, MigrationError, RepoRepository, TaskRepository, compare, createDefaultAdminUser, createUser, formatShortId, generateId, getUserByEmail, hash, initializeDatabase, resolveShortId, runMigrations, seedInitialData, userExists };