@pasko70/pibo 1.13.0 → 1.14.0

package/dist/plugins/context-files-store.js

@@ -1,7 +1,49 @@
 import { createHash, randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
+const CONTEXT_FILE_SCHEMA_VERSION_KEY = "schema-version";
+const CONTEXT_FILE_SCHEMA_VERSION = "2";
+const MANUAL_REVISION_MIGRATION_KEY = "manual-revisions-v2";
+const CONTEXT_FILE_BASE_COLUMNS = [
+    "key",
+    "label",
+    "managed_path",
+    "scope",
+    "source_type",
+    "agent_profile_name",
+    "active_revision_id",
+    "source_ref",
+    "source_hash",
+    "created_at",
+    "updated_at",
+];
+const CONTEXT_FILE_COLUMNS = [
+    ...CONTEXT_FILE_BASE_COLUMNS,
+    "working_content",
+    "source_content",
+];
+const AUTOMATIC_REVISION_COLUMNS = [
+    "id",
+    "context_file_key",
+    "kind",
+    "content_hash",
+    "content",
+    "created_at",
+    "actor_id",
+    "based_on_revision_id",
+    "source_hash_at_creation",
+    "note",
+];
+const MANUAL_REVISION_COLUMNS = [
+    "id",
+    "context_file_key",
+    "name",
+    "content_hash",
+    "content",
+    "created_at",
+    "actor_id",
+];
 function readLegacyManagedStore(storePath) {
     if (!existsSync(storePath))
         return { files: [] };
@@ -40,9 +82,10 @@ function fileRowToRecord(row) {
         scope: row.scope,
         sourceType: row.source_type,
         ...(row.agent_profile_name ? { agentProfileName: row.agent_profile_name } : {}),
-        ...(row.active_revision_id ? { activeRevisionId: row.active_revision_id } : {}),
+        workingContent: row.working_content ?? "",
         ...(row.source_ref ? { sourceRef: row.source_ref } : {}),
         ...(row.source_hash ? { sourceHash: row.source_hash } : {}),
+        ...(row.source_content !== null ? { sourceContent: row.source_content } : {}),
         createdAt: row.created_at,
         updatedAt: row.updated_at,
     };
@@ -51,14 +94,11 @@ function revisionRowToRecord(row) {
     return {
         id: row.id,
         contextFileKey: row.context_file_key,
-        kind: row.kind,
+        name: row.name,
         contentHash: row.content_hash,
         content: row.content,
         createdAt: row.created_at,
         ...(row.actor_id ? { actorId: row.actor_id } : {}),
-        ...(row.based_on_revision_id ? { basedOnRevisionId: row.based_on_revision_id } : {}),
-        ...(row.source_hash_at_creation ? { sourceHashAtCreation: row.source_hash_at_creation } : {}),
-        ...(row.note ? { note: row.note } : {}),
     };
 }
 export class ContextFileMetadataStore {
@@ -71,51 +111,22 @@ export class ContextFileMetadataStore {
         this.db = new DatabaseSync(resolvedPath);
         this.db.exec("PRAGMA busy_timeout = 5000");
         this.db.exec("PRAGMA journal_mode = WAL");
-        this.db.exec(`
-			CREATE TABLE IF NOT EXISTS context_files (
-				key TEXT PRIMARY KEY,
-				label TEXT NOT NULL,
-				managed_path TEXT NOT NULL,
-				scope TEXT NOT NULL,
-				source_type TEXT NOT NULL,
-				agent_profile_name TEXT,
-				active_revision_id TEXT,
-				source_ref TEXT,
-				source_hash TEXT,
-				created_at TEXT NOT NULL,
-				updated_at TEXT NOT NULL
-			);
-
-			CREATE INDEX IF NOT EXISTS idx_context_files_scope
-				ON context_files(scope, updated_at);
-
-			CREATE TABLE IF NOT EXISTS context_file_revisions (
-				id TEXT PRIMARY KEY,
-				context_file_key TEXT NOT NULL,
-				kind TEXT NOT NULL,
-				content_hash TEXT NOT NULL,
-				content TEXT NOT NULL,
-				created_at TEXT NOT NULL,
-				actor_id TEXT,
-				based_on_revision_id TEXT,
-				source_hash_at_creation TEXT,
-				note TEXT
-			);
-
-			CREATE INDEX IF NOT EXISTS idx_context_file_revisions_key
-				ON context_file_revisions(context_file_key, created_at DESC);
-		`);
+        this.migrateStorage();
+        this.assertCompatibleSchema();
         this.migrateLegacyStore();
     }
     listFiles() {
+        this.assertCompatibleSchema();
         const rows = this.db.prepare("SELECT * FROM context_files ORDER BY updated_at DESC").all();
         return rows.map(fileRowToRecord);
     }
     getFile(key) {
+        this.assertCompatibleSchema();
         const row = this.db.prepare("SELECT * FROM context_files WHERE key = ?").get(key);
         return row ? fileRowToRecord(row) : undefined;
     }
     createFile(input) {
+        this.assertCompatibleSchema();
         const createdAt = input.createdAt ?? new Date().toISOString();
         const updatedAt = input.updatedAt ?? createdAt;
         this.db
@@ -128,19 +139,22 @@ export class ContextFileMetadataStore {
 					source_type,
 					agent_profile_name,
 					active_revision_id,
+					working_content,
 					source_ref,
 					source_hash,
+					source_content,
 					created_at,
 					updated_at
-				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 			`)
-            .run(input.key, input.label, input.managedPath, input.scope, "managed", input.agentProfileName ?? null, null, input.sourceRef ?? null, input.sourceHash ?? null, createdAt, updatedAt);
+            .run(input.key, input.label, input.managedPath, input.scope, "managed", input.agentProfileName ?? null, null, input.workingContent, input.sourceRef ?? null, input.sourceHash ?? null, input.sourceContent ?? null, createdAt, updatedAt);
         const record = this.getFile(input.key);
         if (!record)
             throw new Error(`Failed to create context file record "${input.key}"`);
         return record;
     }
     updateFile(input) {
+        this.assertCompatibleSchema();
         this.db
             .prepare(`
 				UPDATE context_files SET
@@ -149,22 +163,26 @@ export class ContextFileMetadataStore {
 					scope = ?,
 					source_type = ?,
 					agent_profile_name = ?,
-					active_revision_id = ?,
+					active_revision_id = NULL,
+					working_content = ?,
 					source_ref = ?,
 					source_hash = ?,
+					source_content = ?,
 					created_at = ?,
 					updated_at = ?
 				WHERE key = ?
 			`)
-            .run(input.label, input.managedPath, input.scope, "managed", input.agentProfileName ?? null, input.activeRevisionId ?? null, input.sourceRef ?? null, input.sourceHash ?? null, input.createdAt, input.updatedAt, input.key);
+            .run(input.label, input.managedPath, input.scope, "managed", input.agentProfileName ?? null, input.workingContent, input.sourceRef ?? null, input.sourceHash ?? null, input.sourceContent ?? null, input.createdAt, input.updatedAt, input.key);
         const record = this.getFile(input.key);
         if (!record)
             throw new Error(`Failed to update context file record "${input.key}"`);
         return record;
     }
     deleteFile(key) {
+        this.assertCompatibleSchema();
         this.db.exec("BEGIN");
         try {
+            this.db.prepare("DELETE FROM context_file_manual_revisions WHERE context_file_key = ?").run(key);
             this.db.prepare("DELETE FROM context_file_revisions WHERE context_file_key = ?").run(key);
             this.db.prepare("DELETE FROM context_files WHERE key = ?").run(key);
             this.db.exec("COMMIT");
@@ -175,62 +193,250 @@ export class ContextFileMetadataStore {
         }
     }
     appendRevision(input) {
+        this.assertCompatibleSchema();
         const id = `rev_${randomUUID()}`;
         const createdAt = input.createdAt ?? new Date().toISOString();
         this.db
             .prepare(`
-				INSERT INTO context_file_revisions (
+				INSERT INTO context_file_manual_revisions (
 					id,
 					context_file_key,
-					kind,
+					name,
 					content_hash,
 					content,
 					created_at,
-					actor_id,
-					based_on_revision_id,
-					source_hash_at_creation,
-					note
-				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+					actor_id
+				) VALUES (?, ?, ?, ?, ?, ?, ?)
 			`)
-            .run(id, input.contextFileKey, input.kind, input.contentHash, input.content, createdAt, input.actorId ?? null, input.basedOnRevisionId ?? null, input.sourceHashAtCreation ?? null, input.note ?? null);
+            .run(id, input.contextFileKey, input.name, input.contentHash, input.content, createdAt, input.actorId ?? null);
         const revision = this.getRevision(id);
         if (!revision)
             throw new Error(`Failed to create context file revision "${id}"`);
         return revision;
     }
     getRevision(id) {
-        const row = this.db.prepare("SELECT * FROM context_file_revisions WHERE id = ?").get(id);
+        this.assertCompatibleSchema();
+        const row = this.db.prepare("SELECT * FROM context_file_manual_revisions WHERE id = ?").get(id);
         return row ? revisionRowToRecord(row) : undefined;
     }
     listRevisions(contextFileKey) {
+        this.assertCompatibleSchema();
         const rows = this.db
-            .prepare("SELECT * FROM context_file_revisions WHERE context_file_key = ? ORDER BY created_at DESC")
+            .prepare("SELECT * FROM context_file_manual_revisions WHERE context_file_key = ? ORDER BY created_at DESC")
             .all(contextFileKey);
         return rows.map(revisionRowToRecord);
     }
-    findLatestSourceSnapshot(contextFileKey, sourceHash) {
-        const row = sourceHash
-            ? this.db
-                .prepare(`
-					SELECT * FROM context_file_revisions
-					WHERE context_file_key = ? AND kind = 'source-snapshot' AND content_hash = ?
-					ORDER BY created_at DESC
-					LIMIT 1
-				`)
-                .get(contextFileKey, sourceHash)
-            : this.db
-                .prepare(`
-					SELECT * FROM context_file_revisions
-					WHERE context_file_key = ? AND kind = 'source-snapshot'
-					ORDER BY created_at DESC
-					LIMIT 1
-				`)
-                .get(contextFileKey);
-        return row ? revisionRowToRecord(row) : undefined;
-    }
     close() {
         this.db.close();
     }
+    columnsFor(table) {
+        if (!this.tableExists(table))
+            return new Set();
+        return new Set(this.db.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name));
+    }
+    hasColumns(table, required) {
+        const columns = this.columnsFor(table);
+        return required.every((column) => columns.has(column));
+    }
+    ensureColumn(table, column, type) {
+        if (this.columnsFor(table).has(column))
+            return;
+        this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+    }
+    tableExists(table) {
+        return Boolean(this.db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(table));
+    }
+    ensureAutomaticRevisionTable() {
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS context_file_revisions (
+				id TEXT PRIMARY KEY,
+				context_file_key TEXT NOT NULL,
+				kind TEXT NOT NULL,
+				content_hash TEXT NOT NULL,
+				content TEXT NOT NULL,
+				created_at TEXT NOT NULL,
+				actor_id TEXT,
+				based_on_revision_id TEXT,
+				source_hash_at_creation TEXT,
+				note TEXT
+			);
+
+			CREATE INDEX IF NOT EXISTS idx_context_file_revisions_key
+				ON context_file_revisions(context_file_key, created_at DESC);
+		`);
+    }
+    ensureManualRevisionTable() {
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS context_file_manual_revisions (
+				id TEXT PRIMARY KEY,
+				context_file_key TEXT NOT NULL,
+				name TEXT NOT NULL,
+				content_hash TEXT NOT NULL,
+				content TEXT NOT NULL,
+				created_at TEXT NOT NULL,
+				actor_id TEXT
+			);
+
+			CREATE INDEX IF NOT EXISTS idx_context_file_manual_revisions_key
+				ON context_file_manual_revisions(context_file_key, created_at DESC);
+		`);
+    }
+    assertCompatibleSchema() {
+        const version = this.db.prepare("SELECT value FROM context_file_store_meta WHERE key = ?").get(CONTEXT_FILE_SCHEMA_VERSION_KEY);
+        const compatible = version?.value === CONTEXT_FILE_SCHEMA_VERSION
+            && this.hasColumns("context_files", CONTEXT_FILE_COLUMNS)
+            && this.hasColumns("context_file_revisions", AUTOMATIC_REVISION_COLUMNS)
+            && this.hasColumns("context_file_manual_revisions", MANUAL_REVISION_COLUMNS);
+        if (compatible)
+            return;
+        throw new Error(`Context Files metadata schema is incompatible with this Pibo version (expected ${CONTEXT_FILE_SCHEMA_VERSION}, found ${version?.value ?? "unversioned"}). ` +
+            "Activate a matching package version or use an isolated PIBO_HOME before accessing Context Files storage.");
+    }
+    migrateStorage() {
+        let recovered = [];
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            this.db.exec(`
+				CREATE TABLE IF NOT EXISTS context_file_store_meta (
+					key TEXT PRIMARY KEY,
+					value TEXT NOT NULL
+				);
+			`);
+            const version = this.db.prepare("SELECT value FROM context_file_store_meta WHERE key = ?").get(CONTEXT_FILE_SCHEMA_VERSION_KEY);
+            if (version?.value === CONTEXT_FILE_SCHEMA_VERSION) {
+                this.db.exec("COMMIT");
+                return;
+            }
+            if (version?.value !== undefined && version.value !== "1") {
+                throw new Error(`Unsupported Context Files metadata schema version ${version.value}; expected ${CONTEXT_FILE_SCHEMA_VERSION}`);
+            }
+            this.db.exec(`
+				CREATE TABLE IF NOT EXISTS context_files (
+					key TEXT PRIMARY KEY,
+					label TEXT NOT NULL,
+					managed_path TEXT NOT NULL,
+					scope TEXT NOT NULL,
+					source_type TEXT NOT NULL,
+					agent_profile_name TEXT,
+					active_revision_id TEXT,
+					working_content TEXT,
+					source_ref TEXT,
+					source_hash TEXT,
+					source_content TEXT,
+					created_at TEXT NOT NULL,
+					updated_at TEXT NOT NULL
+				);
+
+				CREATE INDEX IF NOT EXISTS idx_context_files_scope
+					ON context_files(scope, updated_at);
+			`);
+            if (!this.hasColumns("context_files", CONTEXT_FILE_BASE_COLUMNS)) {
+                throw new Error("Context Files metadata has an unsupported context_files table shape");
+            }
+            this.ensureColumn("context_files", "working_content", "TEXT");
+            this.ensureColumn("context_files", "source_content", "TEXT");
+            const revisionTableExists = this.tableExists("context_file_revisions");
+            const revisionColumns = this.columnsFor("context_file_revisions");
+            const hasAutomaticRevisionSchema = revisionTableExists
+                && AUTOMATIC_REVISION_COLUMNS.every((column) => revisionColumns.has(column));
+            const hasManualOnlyRevisionSchema = revisionTableExists
+                && !hasAutomaticRevisionSchema
+                && MANUAL_REVISION_COLUMNS.every((column) => revisionColumns.has(column));
+            if (revisionTableExists && !hasAutomaticRevisionSchema && !hasManualOnlyRevisionSchema) {
+                throw new Error("Context Files metadata has an unsupported context_file_revisions table shape");
+            }
+            const files = this.db.prepare(`
+				SELECT key, managed_path, active_revision_id, working_content, source_content
+				FROM context_files
+			`).all();
+            recovered = files.map((file) => {
+                const fileExists = existsSync(file.managed_path);
+                const activeContent = !fileExists && revisionTableExists && file.active_revision_id
+                    ? this.db.prepare("SELECT content FROM context_file_revisions WHERE id = ?").get(file.active_revision_id)?.content
+                    : undefined;
+                const workingContent = fileExists
+                    ? readFileSync(file.managed_path, "utf8")
+                    : file.working_content ?? activeContent ?? "";
+                const sourceContent = file.source_content ?? (hasAutomaticRevisionSchema
+                    ? this.db.prepare(`
+						SELECT content FROM context_file_revisions
+						WHERE context_file_key = ? AND kind = 'source-snapshot'
+						ORDER BY created_at DESC
+						LIMIT 1
+					`).get(file.key)?.content
+                    : undefined);
+                return {
+                    key: file.key,
+                    managedPath: file.managed_path,
+                    workingContent,
+                    sourceContent,
+                    restoreManagedFile: !fileExists && (file.working_content !== null || activeContent !== undefined),
+                };
+            });
+            if (hasManualOnlyRevisionSchema) {
+                this.db.exec("DROP INDEX IF EXISTS idx_context_file_revisions_key");
+                if (this.tableExists("context_file_manual_revisions")) {
+                    if (!this.hasColumns("context_file_manual_revisions", MANUAL_REVISION_COLUMNS)) {
+                        throw new Error("Context Files metadata has an unsupported context_file_manual_revisions table shape");
+                    }
+                    this.db.exec(`
+						INSERT OR IGNORE INTO context_file_manual_revisions (
+							id, context_file_key, name, content_hash, content, created_at, actor_id
+						)
+						SELECT id, context_file_key, name, content_hash, content, created_at, actor_id
+						FROM context_file_revisions;
+						DROP TABLE context_file_revisions;
+					`);
+                }
+                else {
+                    this.db.exec("ALTER TABLE context_file_revisions RENAME TO context_file_manual_revisions");
+                }
+                this.db.exec(`
+					CREATE INDEX IF NOT EXISTS idx_context_file_manual_revisions_key
+						ON context_file_manual_revisions(context_file_key, created_at DESC);
+				`);
+            }
+            this.ensureAutomaticRevisionTable();
+            this.ensureManualRevisionTable();
+            if (hasAutomaticRevisionSchema && revisionColumns.has("name")) {
+                this.db.exec(`
+					INSERT OR IGNORE INTO context_file_manual_revisions (
+						id, context_file_key, name, content_hash, content, created_at, actor_id
+					)
+					SELECT id, context_file_key, name, content_hash, content, created_at, actor_id
+					FROM context_file_revisions
+					WHERE name IS NOT NULL;
+				`);
+            }
+            for (const file of recovered) {
+                this.db.prepare(`
+					UPDATE context_files
+					SET active_revision_id = NULL, working_content = ?, source_content = ?
+					WHERE key = ?
+				`).run(file.workingContent, file.sourceContent ?? null, file.key);
+            }
+            const migratedAt = new Date().toISOString();
+            this.db.prepare(`
+				INSERT INTO context_file_store_meta (key, value) VALUES (?, ?)
+				ON CONFLICT(key) DO UPDATE SET value = excluded.value
+			`).run(CONTEXT_FILE_SCHEMA_VERSION_KEY, CONTEXT_FILE_SCHEMA_VERSION);
+            this.db.prepare(`
+				INSERT INTO context_file_store_meta (key, value) VALUES (?, ?)
+				ON CONFLICT(key) DO UPDATE SET value = excluded.value
+			`).run(MANUAL_REVISION_MIGRATION_KEY, migratedAt);
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+        for (const file of recovered) {
+            if (!file.restoreManagedFile)
+                continue;
+            mkdirSync(dirname(file.managedPath), { recursive: true });
+            writeFileSync(file.managedPath, file.workingContent, "utf8");
+        }
+    }
     migrateLegacyStore() {
         if (!this.legacyStorePath)
             return;
@@ -244,9 +450,11 @@ export class ContextFileMetadataStore {
         try {
             for (const file of legacyStore.files) {
                 const resolvedPath = resolve(file.path);
-                const createdAt = existsSync(resolvedPath)
+                const fileExists = existsSync(resolvedPath);
+                const createdAt = fileExists
                     ? statSync(resolvedPath).mtime.toISOString()
                     : new Date().toISOString();
+                const workingContent = fileExists ? readFileSync(resolvedPath, "utf8") : "";
                 this.db
                     .prepare(`
 						INSERT INTO context_files (
@@ -257,37 +465,15 @@ export class ContextFileMetadataStore {
 							source_type,
 							agent_profile_name,
 							active_revision_id,
+							working_content,
 							source_ref,
 							source_hash,
+							source_content,
 							created_at,
 							updated_at
-						) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+						) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 					`)
-                    .run(file.key, file.label, resolvedPath, file.scope, "managed", file.agentProfileName ?? null, null, null, null, createdAt, createdAt);
-                if (!existsSync(resolvedPath))
-                    continue;
-                const content = readFileSync(resolvedPath, "utf8");
-                const contentHash = hashContextFileContent(content);
-                const revisionId = `rev_${randomUUID()}`;
-                this.db
-                    .prepare(`
-						INSERT INTO context_file_revisions (
-							id,
-							context_file_key,
-							kind,
-							content_hash,
-							content,
-							created_at,
-							actor_id,
-							based_on_revision_id,
-							source_hash_at_creation,
-							note
-						) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-					`)
-                    .run(revisionId, file.key, "working", contentHash, content, createdAt, null, null, null, "Legacy managed file import");
-                this.db
-                    .prepare("UPDATE context_files SET active_revision_id = ?, updated_at = ? WHERE key = ?")
-                    .run(revisionId, createdAt, file.key);
+                    .run(file.key, file.label, resolvedPath, file.scope, "managed", file.agentProfileName ?? null, null, workingContent, null, null, null, createdAt, createdAt);
             }
             this.db.exec("COMMIT");
         }