chronicle-ai 0.0.1

package/packages/daemon/dist/services/DatabaseService.js

@@ -0,0 +1,692 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseService = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const sqliteVec = __importStar(require("sqlite-vec"));
+class DatabaseService {
+    dataDir;
+    db;
+    constructor(dataDir = '.chronicle') {
+        this.dataDir = dataDir;
+        if (!fs_1.default.existsSync(dataDir)) {
+            fs_1.default.mkdirSync(dataDir, { recursive: true });
+        }
+        const dbPath = path_1.default.join(dataDir, 'db.sqlite');
+        this.db = new better_sqlite3_1.default(dbPath);
+        // Load sqlite-vec extension
+        try {
+            this.db.loadExtension(sqliteVec.getLoadablePath());
+        }
+        catch (e) {
+            console.warn('⚠️ Could not load sqlite-vec extension. Vector search will be disabled.', e);
+        }
+        this.initSchema();
+    }
+    initSchema() {
+        this.db.pragma('journal_mode = WAL');
+        // Structural Memory: Files
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS files (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                path TEXT UNIQUE NOT NULL,
+                hash TEXT,
+                last_modified INTEGER,
+                last_indexed INTEGER
+            );
+        `);
+        // Events: What happened
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS events (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                type TEXT NOT NULL,
+                payload TEXT,
+                created_at INTEGER DEFAULT (unixepoch())
+            );
+        `);
+        // Jobs: Persistent Queue
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS jobs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                data TEXT NOT NULL,
+                status TEXT DEFAULT 'pending', -- pending, processing, completed, failed
+                error TEXT,
+                created_at INTEGER DEFAULT (unixepoch()),
+                updated_at INTEGER DEFAULT (unixepoch())
+            );
+        `);
+        // Projects: Monitored Repositories
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS projects (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                path TEXT UNIQUE NOT NULL,
+                name TEXT,
+                type TEXT,
+                created_at INTEGER,
+                is_paused INTEGER DEFAULT 0
+            );
+        `);
+        // Migration: Add is_paused if missing
+        try {
+            this.db.exec('ALTER TABLE projects ADD COLUMN is_paused INTEGER DEFAULT 0');
+        }
+        catch (e) {
+            // Ignore if column exists
+        }
+        // Migration: Fix NULL timestamps in jobs table
+        try {
+            this.db.exec(`
+                UPDATE jobs SET created_at = unixepoch() WHERE created_at IS NULL OR created_at = 0;
+                UPDATE jobs SET updated_at = unixepoch() WHERE updated_at IS NULL OR updated_at = 0;
+            `);
+        }
+        catch (e) {
+            // Ignore errors
+        }
+        // Embeddings: Vector Store
+        try {
+            // 768 dimensions for Gemini Embeddings
+            this.db.exec(`
+                CREATE VIRTUAL TABLE IF NOT EXISTS embeddings USING vec0(
+                    file_id INTEGER,
+                    chunk_index INTEGER,
+                    embedding FLOAT[768]
+                );
+            `);
+        }
+        catch (error) {
+            console.error('Failed to create embeddings table (sqlite-vec might be missing):', error);
+        }
+        // Doc Stages: Track multi-stage documentation progress
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS doc_stages (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                project_id INTEGER NOT NULL UNIQUE,
+                current_stage INTEGER DEFAULT 0,
+                total_stages INTEGER DEFAULT 4,
+                coverage_plan TEXT,
+                last_updated INTEGER DEFAULT (unixepoch()),
+                FOREIGN KEY (project_id) REFERENCES projects(id)
+            );
+        `);
+        // ===== Phase 1.5: Versioning Tables =====
+        // Doc Versions: Each generation run creates a version
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS doc_versions (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                project_id INTEGER NOT NULL,
+                version_number INTEGER NOT NULL,
+                trigger_type TEXT, -- 'init', 'on_change', 'on_commit', 'schedule', 'manual'
+                commit_hash TEXT,
+                status TEXT DEFAULT 'draft', -- draft, pending_review, active, archived
+                created_at INTEGER DEFAULT (unixepoch()),
+                FOREIGN KEY (project_id) REFERENCES projects(id)
+            );
+        `);
+        // Doc Files: Stores content for each version
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS doc_files (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                version_id INTEGER NOT NULL,
+                path TEXT NOT NULL,
+                content TEXT,
+                content_hash TEXT,
+                created_at INTEGER DEFAULT (unixepoch()),
+                FOREIGN KEY (version_id) REFERENCES doc_versions(id)
+            );
+        `);
+        // Thought Logs: Chain-of-thought for each doc file
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS thought_logs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                version_id INTEGER NOT NULL,
+                doc_path TEXT,
+                thinking_summary TEXT,
+                created_at INTEGER DEFAULT (unixepoch()),
+                FOREIGN KEY (version_id) REFERENCES doc_versions(id)
+            );
+        `);
+        // Assumptions: Claims made in docs that need verification
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS assumptions (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                doc_file_id INTEGER NOT NULL,
+                claim TEXT NOT NULL,
+                verified INTEGER DEFAULT 0, -- 0 = unverified, 1 = verified, -1 = rejected
+                verification_method TEXT,
+                verified_at INTEGER,
+                FOREIGN KEY (doc_file_id) REFERENCES doc_files(id)
+            );
+        `);
+        // ===== Phase 1.6: AI Activity Logging =====
+        // AI Activity: Central log of all AI calls for the thinking platform
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS ai_activity (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                project_id INTEGER,
+                version_id INTEGER,
+                activity_type TEXT NOT NULL, -- 'analyze', 'generate', 'plan', 'embed', 'other'
+                prompt_summary TEXT,
+                response_preview TEXT,
+                thinking_summary TEXT,
+                tokens_used INTEGER,
+                duration_ms INTEGER,
+                status TEXT DEFAULT 'completed', -- 'running', 'completed', 'error'
+                created_at INTEGER DEFAULT (unixepoch() * 1000), -- Milliseconds for UI
+                FOREIGN KEY (project_id) REFERENCES projects(id),
+                FOREIGN KEY (version_id) REFERENCES doc_versions(id)
+            );
+        `);
+        // Create index for fast AI activity queries
+        this.db.exec(`
+            CREATE INDEX IF NOT EXISTS idx_ai_activity_created 
+            ON ai_activity(created_at DESC);
+        `);
+        console.log('📦 Database initialized.');
+    }
+    init() {
+        // Public init for external use if needed
+    }
+    addProject(pathStr) {
+        const name = path_1.default.basename(pathStr);
+        return this.db.prepare(`
+            INSERT INTO projects (path, name, created_at)
+            VALUES (?, ?, unixepoch())
+            ON CONFLICT(path) DO NOTHING
+        `).run(pathStr, name);
+    }
+    removeProject(pathToRemove) {
+        // Normalize path - remove trailing slashes and resolve to absolute
+        let normalizedPath = pathToRemove.trim();
+        if (normalizedPath.endsWith('/') || normalizedPath.endsWith('\\')) {
+            normalizedPath = normalizedPath.slice(0, -1);
+        }
+        // Resolve to absolute path if not already absolute
+        if (!path_1.default.isAbsolute(normalizedPath)) {
+            normalizedPath = path_1.default.resolve(normalizedPath);
+        }
+        else {
+            normalizedPath = path_1.default.resolve(normalizedPath);
+        }
+        // Try exact match first
+        let result = this.db.prepare(`
+            DELETE FROM projects WHERE path = ?
+        `).run(normalizedPath);
+        // If no match, try to find by normalizing stored paths
+        if (result.changes === 0) {
+            const projects = this.getProjects();
+            for (const project of projects) {
+                let storedPath = project.path.trim();
+                if (storedPath.endsWith('/') || storedPath.endsWith('\\')) {
+                    storedPath = storedPath.slice(0, -1);
+                }
+                storedPath = path_1.default.resolve(storedPath);
+                if (storedPath === normalizedPath) {
+                    result = this.db.prepare(`
+                        DELETE FROM projects WHERE id = ?
+                    `).run(project.id);
+                    console.log(`✅ Removed project by ID: ${project.id} (path matched after normalization)`);
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+    toggleProjectPaused(path, paused) {
+        return this.db.prepare(`
+            UPDATE projects SET is_paused = ? WHERE path = ?
+        `).run(paused ? 1 : 0, path);
+    }
+    getProjects() {
+        return this.db.prepare('SELECT * FROM projects').all();
+    }
+    getProjectByPath(path) {
+        return this.db.prepare('SELECT * FROM projects WHERE path = ?').get(path);
+    }
+    getFile(path) {
+        return this.db.prepare('SELECT * FROM files WHERE path = ?').get(path);
+    }
+    upsertFile(path, hash, mtime) {
+        return this.db.prepare(`
+            INSERT INTO files (path, hash, last_modified, last_indexed)
+            VALUES (?, ?, ?, unixepoch())
+            ON CONFLICT(path) DO UPDATE SET
+                hash = excluded.hash,
+                last_modified = excluded.last_modified,
+                last_indexed = unixepoch()
+        `).run(path, hash, mtime);
+    }
+    logEvent(type, payload) {
+        return this.db.prepare(`
+            INSERT INTO events (type, payload)
+            VALUES (?, ?)
+        `).run(type, JSON.stringify(payload));
+    }
+    raw() {
+        return this.db;
+    }
+    findSimilarSegments(vector, limit = 5) {
+        // vec0 search syntax: 
+        // SELECT rowid, distance FROM embeddings WHERE embedding MATCH ? ORDER BY distance LIMIT ?
+        // Note: 'embedding' column in WHERE clause, standard pattern for virtual tables.
+        // Ensure vector is Float32Array
+        const floatVector = new Float32Array(vector);
+        const results = this.db.prepare(`
+            SELECT 
+                e.file_id, 
+                e.chunk_index, 
+                distance
+            FROM embeddings e
+            WHERE embedding MATCH ?
+            ORDER BY distance
+            LIMIT ?
+        `).all(floatVector, limit);
+        // Hydrate with file info
+        return results.map(r => {
+            const file = this.db.prepare('SELECT path FROM files WHERE id = ?').get(r.file_id);
+            return {
+                filePath: file ? file.path : 'unknown',
+                score: r.distance, // lower is better in Euclidean? check sqlite-vec config. Default L2.
+                ...r
+            };
+        });
+    }
+    // --- Job Queue Methods ---
+    enqueueJob(name, data) {
+        return this.db.prepare(`
+            INSERT INTO jobs (name, data, status)
+            VALUES (?, ?, 'pending')
+        `).run(name, JSON.stringify(data));
+    }
+    getNextPendingJob() {
+        // Simple FIFO: get oldest pending job
+        const job = this.db.prepare(`
+            SELECT * FROM jobs 
+            WHERE status = 'pending' 
+            ORDER BY created_at ASC 
+            LIMIT 1
+        `).get();
+        return job ? { ...job, data: JSON.parse(job.data) } : null;
+    }
+    updateJobStatus(id, status, error) {
+        return this.db.prepare(`
+            UPDATE jobs 
+            SET status = ?, error = ?, updated_at = unixepoch()
+            WHERE id = ?
+        `).run(status, error || null, id);
+    }
+    resetProcessingJobs() {
+        // On startup, reset 'processing' jobs to 'pending' so they aren't lost
+        return this.db.prepare(`
+            UPDATE jobs 
+            SET status = 'pending' 
+            WHERE status = 'processing'
+        `).run();
+    }
+    /**
+     * Clears all pending jobs from the queue.
+     */
+    clearPendingJobs() {
+        return this.db.prepare(`
+            DELETE FROM jobs WHERE status = 'pending'
+        `).run();
+    }
+    /**
+     * Cancels (marks as failed) the currently processing job.
+     */
+    cancelCurrentJob() {
+        return this.db.prepare(`
+            UPDATE jobs 
+            SET status = 'failed', error = 'Cancelled by user', updated_at = unixepoch()
+            WHERE status = 'processing'
+        `).run();
+    }
+    /**
+     * Clears the entire queue (pending jobs) and cancels current job.
+     */
+    clearQueue() {
+        this.cancelCurrentJob();
+        return this.clearPendingJobs();
+    }
+    /**
+     * Gets count of pending jobs.
+     */
+    getPendingJobCount() {
+        const result = this.db.prepare(`SELECT COUNT(*) as count FROM jobs WHERE status = 'pending'`).get();
+        return result.count;
+    }
+    // ===== Doc Stage Management =====
+    /**
+     * Gets the documentation stage for a project.
+     */
+    getDocStage(projectId) {
+        const result = this.db.prepare(`
+            SELECT current_stage, total_stages, coverage_plan FROM doc_stages WHERE project_id = ?
+        `).get(projectId);
+        if (!result)
+            return null;
+        return {
+            currentStage: result.current_stage,
+            totalStages: result.total_stages,
+            coveragePlan: result.coverage_plan
+        };
+    }
+    /**
+     * Creates or resets doc stage for a project.
+     */
+    setDocStage(projectId, coveragePlan, totalStages = 4) {
+        this.db.prepare(`
+            INSERT INTO doc_stages (project_id, current_stage, total_stages, coverage_plan, last_updated)
+            VALUES (?, 0, ?, ?, unixepoch())
+            ON CONFLICT(project_id) DO UPDATE SET
+                current_stage = 0,
+                total_stages = excluded.total_stages,
+                coverage_plan = excluded.coverage_plan,
+                last_updated = unixepoch()
+        `).run(projectId, totalStages, coveragePlan);
+    }
+    /**
+     * Updates the current stage for a project.
+     */
+    updateDocStage(projectId, stage) {
+        this.db.prepare(`
+            UPDATE doc_stages SET current_stage = ?, last_updated = unixepoch() WHERE project_id = ?
+        `).run(stage, projectId);
+    }
+    /**
+     * Resets the doc stage to 0 (hides the stage counter in UI).
+     */
+    resetDocStage(projectId) {
+        this.db.prepare(`
+            UPDATE doc_stages SET current_stage = 0, last_updated = unixepoch() WHERE project_id = ?
+        `).run(projectId);
+    }
+    /**
+     * Gets coverage plan JSON for a project.
+     */
+    getDocCoveragePlan(projectId) {
+        const result = this.db.prepare(`
+            SELECT coverage_plan FROM doc_stages WHERE project_id = ?
+        `).get(projectId);
+        if (!result || !result.coverage_plan)
+            return null;
+        try {
+            return JSON.parse(result.coverage_plan);
+        }
+        catch {
+            return null;
+        }
+    }
+    // ===== Doc Version Management =====
+    /**
+     * Creates a new doc version for a project.
+     */
+    createDocVersion(projectId, triggerType, commitHash) {
+        // Get next version number
+        const latest = this.db.prepare(`
+            SELECT MAX(version_number) as max_version FROM doc_versions WHERE project_id = ?
+        `).get(projectId);
+        const nextVersion = (latest?.max_version ?? 0) + 1;
+        const result = this.db.prepare(`
+            INSERT INTO doc_versions (project_id, version_number, trigger_type, commit_hash, status)
+            VALUES (?, ?, ?, ?, 'draft')
+        `).run(projectId, nextVersion, triggerType, commitHash || null);
+        return Number(result.lastInsertRowid);
+    }
+    /**
+     * Adds a doc file to a version.
+     */
+    addDocFile(versionId, path, content) {
+        const hash = require('crypto').createHash('md5').update(content).digest('hex');
+        const result = this.db.prepare(`
+            INSERT INTO doc_files (version_id, path, content, content_hash)
+            VALUES (?, ?, ?, ?)
+        `).run(versionId, path, content, hash);
+        return Number(result.lastInsertRowid);
+    }
+    /**
+     * Adds a thought log entry for a version.
+     */
+    addThoughtLog(versionId, docPath, thinkingSummary) {
+        this.db.prepare(`
+            INSERT INTO thought_logs (version_id, doc_path, thinking_summary)
+            VALUES (?, ?, ?)
+        `).run(versionId, docPath, thinkingSummary);
+    }
+    /**
+     * Adds an assumption to a doc file.
+     */
+    addAssumption(docFileId, claim) {
+        const result = this.db.prepare(`
+            INSERT INTO assumptions (doc_file_id, claim, verified)
+            VALUES (?, ?, 0)
+        `).run(docFileId, claim);
+        return Number(result.lastInsertRowid);
+    }
+    /**
+     * Updates assumption verification status.
+     */
+    verifyAssumption(assumptionId, verified, method) {
+        this.db.prepare(`
+            UPDATE assumptions 
+            SET verified = ?, verification_method = ?, verified_at = unixepoch()
+            WHERE id = ?
+        `).run(verified ? 1 : -1, method || null, assumptionId);
+    }
+    /**
+     * Gets all versions for a project.
+     */
+    getDocVersions(projectId) {
+        return this.db.prepare(`
+            SELECT id, version_number, trigger_type, status, created_at 
+            FROM doc_versions 
+            WHERE project_id = ? 
+            ORDER BY version_number DESC
+        `).all(projectId);
+    }
+    /**
+     * Gets the active version for a project.
+     */
+    getActiveDocVersion(projectId) {
+        return this.db.prepare(`
+            SELECT id, version_number FROM doc_versions 
+            WHERE project_id = ? AND status = 'active'
+        `).get(projectId) || null;
+    }
+    /**
+     * Activates a version (sets it as current, archives others).
+     */
+    activateDocVersion(versionId, projectId) {
+        // Archive current active
+        this.db.prepare(`
+            UPDATE doc_versions SET status = 'archived' 
+            WHERE project_id = ? AND status = 'active'
+        `).run(projectId);
+        // Activate new version
+        this.db.prepare(`
+            UPDATE doc_versions SET status = 'active' WHERE id = ?
+        `).run(versionId);
+    }
+    /**
+     * Updates version status.
+     */
+    updateDocVersionStatus(versionId, status) {
+        this.db.prepare(`
+            UPDATE doc_versions SET status = ? WHERE id = ?
+        `).run(status, versionId);
+    }
+    /**
+     * Gets doc files for a version.
+     */
+    getDocFiles(versionId) {
+        return this.db.prepare(`
+            SELECT id, path, content FROM doc_files WHERE version_id = ?
+        `).all(versionId);
+    }
+    /**
+     * Gets thought logs for a version.
+     */
+    getThoughtLogs(versionId) {
+        return this.db.prepare(`
+            SELECT doc_path, thinking_summary FROM thought_logs WHERE version_id = ?
+        `).all(versionId);
+    }
+    /**
+     * Gets assumptions for a doc file.
+     */
+    getAssumptions(docFileId) {
+        return this.db.prepare(`
+            SELECT id, claim, verified FROM assumptions WHERE doc_file_id = ?
+        `).all(docFileId);
+    }
+    /**
+     * Gets unverified assumptions for a version.
+     */
+    getUnverifiedAssumptions(versionId) {
+        return this.db.prepare(`
+            SELECT a.id, a.claim, df.path as doc_path
+            FROM assumptions a
+            JOIN doc_files df ON a.doc_file_id = df.id
+            WHERE df.version_id = ? AND a.verified = 0
+        `).all(versionId);
+    }
+    // ===== AI Activity Methods (Phase 1.6) =====
+    /**
+     * Logs an AI activity for the central thinking platform.
+     */
+    logAIActivity(data) {
+        const stmt = this.db.prepare(`
+            INSERT INTO ai_activity (
+                project_id, version_id, activity_type, prompt_summary, 
+                response_preview, thinking_summary, tokens_used, duration_ms, status, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+        const result = stmt.run(data.projectId || null, data.versionId || null, data.activityType, data.promptSummary?.slice(0, 200) || null, // Truncate for storage
+        data.responsePreview?.slice(0, 500) || null, data.thinkingSummary || null, data.tokensUsed || null, data.durationMs || null, data.status || 'completed', Date.now() // Use JS timestamp (milliseconds)
+        );
+        return result.lastInsertRowid;
+    }
+    /**
+     * Updates an existing AI activity (e.g., when it completes).
+     */
+    updateAIActivity(id, data) {
+        const updates = [];
+        const values = [];
+        if (data.responsePreview !== undefined) {
+            updates.push('response_preview = ?');
+            values.push(data.responsePreview.slice(0, 500));
+        }
+        if (data.thinkingSummary !== undefined) {
+            updates.push('thinking_summary = ?');
+            values.push(data.thinkingSummary);
+        }
+        if (data.tokensUsed !== undefined) {
+            updates.push('tokens_used = ?');
+            values.push(data.tokensUsed);
+        }
+        if (data.durationMs !== undefined) {
+            updates.push('duration_ms = ?');
+            values.push(data.durationMs);
+        }
+        if (data.status !== undefined) {
+            updates.push('status = ?');
+            values.push(data.status);
+        }
+        if (updates.length > 0) {
+            values.push(id);
+            this.db.prepare(`UPDATE ai_activity SET ${updates.join(', ')} WHERE id = ?`).run(...values);
+        }
+    }
+    /**
+     * Gets recent AI activity (for live thinking panel).
+     */
+    getRecentAIActivity(limit = 20) {
+        return this.db.prepare(`
+            SELECT 
+                a.*,
+                p.path as project_path
+            FROM ai_activity a
+            LEFT JOIN projects p ON a.project_id = p.id
+            ORDER BY a.created_at DESC
+            LIMIT ?
+        `).all(limit);
+    }
+    /**
+     * Gets AI activity for a specific version.
+     */
+    getActivityForVersion(versionId) {
+        return this.db.prepare(`
+            SELECT * FROM ai_activity 
+            WHERE version_id = ? 
+            ORDER BY created_at ASC
+        `).all(versionId);
+    }
+    /**
+     * Updates assumption status.
+     * verified: 0=unverified, 1=verified, -1=rejected
+     */
+    updateAssumptionStatus(id, verified, method) {
+        this.db.prepare(`
+            UPDATE assumptions 
+            SET verified = ?, verification_method = ?, verified_at = (unixepoch() * 1000)
+            WHERE id = ?
+        `).run(verified, method, id);
+    }
+    /**
+     * Gets doc file ID by version and path.
+     */
+    getDocFileId(versionId, docPath) {
+        const result = this.db.prepare(`
+            SELECT id FROM doc_files WHERE version_id = ? AND path = ?
+        `).get(versionId, docPath);
+        return result?.id || null;
+    }
+    /**
+     * Updates doc file content (correction).
+     */
+    updateDocFileContent(id, content) {
+        this.db.prepare(`
+            UPDATE doc_files SET content = ? WHERE id = ?
+        `).run(content, id);
+    }
+}
+exports.DatabaseService = DatabaseService;
+//# sourceMappingURL=DatabaseService.js.map