scene-capability-engine 3.6.3 → 3.6.4

package/lib/runtime/project-timeline.js

@@ -2,6 +2,7 @@
 const { spawnSync } = require('child_process');
 const fs = require('fs-extra');
 const minimatchModule = require('minimatch');
+const { getSceStateStore } = require('../state/sce-state-store');
 
 const minimatch = typeof minimatchModule === 'function'
   ? minimatchModule
@@ -86,13 +87,25 @@ function createSnapshotId(prefix = 'ts') {
 }
 
 class ProjectTimelineStore {
-  constructor(projectPath = process.cwd(), fileSystem = fs) {
+  constructor(projectPath = process.cwd(), fileSystem = fs, options = {}) {
     this._projectPath = projectPath;
     this._fileSystem = fileSystem;
     this._timelineDir = path.join(projectPath, TIMELINE_DIR);
     this._indexPath = path.join(this._timelineDir, TIMELINE_INDEX_FILE);
     this._snapshotsDir = path.join(this._timelineDir, TIMELINE_SNAPSHOTS_DIR);
     this._configPath = path.join(projectPath, TIMELINE_CONFIG_RELATIVE_PATH);
+    this._env = options.env || process.env;
+    this._stateStore = options.stateStore || getSceStateStore(projectPath, {
+      fileSystem: this._fileSystem,
+      env: this._env,
+      sqliteModule: options.sqliteModule
+    });
+    this._preferSqliteReads = normalizeBoolean(
+      options.preferSqliteReads !== undefined
+        ? options.preferSqliteReads
+        : (this._env && this._env.SCE_TIMELINE_PREFER_SQLITE_READS),
+      true
+    );
   }
 
   async getConfig() {
@@ -166,8 +179,10 @@ class ProjectTimelineStore {
       };
     }
 
-    const index = await this._readIndex();
-    const latest = index.snapshots[0] || null;
+    const readResult = await this._readTimelineEntriesForRead({ limit: 1 });
+    const latest = Array.isArray(readResult.entries) && readResult.entries.length > 0
+      ? readResult.entries[0]
+      : null;
     const intervalMinutes = normalizePositiveInteger(options.intervalMinutes, config.auto_interval_minutes, 24 * 60);
 
     if (latest && latest.created_at) {
@@ -287,6 +302,7 @@ class ProjectTimelineStore {
     }
 
     await this._writeIndex(index);
+    await this._syncTimelineIndexEntries([entry], 'runtime.project-timeline.save');
 
     return {
       ...entry,
@@ -296,21 +312,21 @@ class ProjectTimelineStore {
   }
 
   async listSnapshots(options = {}) {
-    const index = await this._readIndex();
     const trigger = `${options.trigger || ''}`.trim();
     const limit = normalizePositiveInteger(options.limit, 20, 1000);
-
-    let snapshots = Array.isArray(index.snapshots) ? [...index.snapshots] : [];
-    if (trigger) {
-      snapshots = snapshots.filter((item) => `${item.trigger || ''}`.trim() === trigger);
-    }
-    snapshots = snapshots.slice(0, limit);
+    const readResult = await this._readTimelineEntriesForRead({
+      trigger,
+      limit
+    });
+    const consistency = await this._getTimelineIndexConsistency();
 
     return {
       mode: 'timeline-list',
       success: true,
-      total: snapshots.length,
-      snapshots
+      total: readResult.entries.length,
+      read_source: readResult.source,
+      consistency,
+      snapshots: readResult.entries
     };
   }
 
@@ -320,8 +336,8 @@ class ProjectTimelineStore {
       throw new Error('snapshotId is required');
     }
 
-    const index = await this._readIndex();
-    const entry = index.snapshots.find((item) => item.snapshot_id === normalizedId);
+    const resolved = await this._resolveTimelineEntryBySnapshotIdWithSource(normalizedId);
+    const entry = resolved.entry;
     if (!entry) {
       throw new Error(`Timeline snapshot not found: ${normalizedId}`);
     }
@@ -346,6 +362,8 @@ class ProjectTimelineStore {
     return {
       mode: 'timeline-show',
       success: true,
+      read_source: resolved.source,
+      consistency: await this._getTimelineIndexConsistency(),
       snapshot: entry,
       metadata,
       files
@@ -359,8 +377,7 @@ class ProjectTimelineStore {
     }
 
     const config = await this.getConfig();
-    const index = await this._readIndex();
-    const entry = index.snapshots.find((item) => item.snapshot_id === normalizedId);
+    const entry = await this._resolveTimelineEntryBySnapshotId(normalizedId);
     if (!entry) {
       throw new Error(`Timeline snapshot not found: ${normalizedId}`);
     }
@@ -416,6 +433,174 @@ class ProjectTimelineStore {
     };
   }
 
+  _normalizeTimelineIndexedEntry(row = {}) {
+    return {
+      snapshot_id: `${row.snapshot_id || ''}`.trim(),
+      created_at: `${row.created_at || ''}`.trim(),
+      trigger: `${row.trigger || ''}`.trim(),
+      event: `${row.event || ''}`.trim(),
+      summary: `${row.summary || ''}`.trim(),
+      scene_id: row.scene_id ? `${row.scene_id}`.trim() : null,
+      session_id: row.session_id ? `${row.session_id}`.trim() : null,
+      command: row.command ? `${row.command}`.trim() : null,
+      file_count: Number.isFinite(Number(row.file_count)) ? Number(row.file_count) : 0,
+      total_bytes: Number.isFinite(Number(row.total_bytes)) ? Number(row.total_bytes) : 0,
+      path: `${row.snapshot_path || row.path || ''}`.trim(),
+      git: row && typeof row.git === 'object' ? row.git : {}
+    };
+  }
+
+  async _readTimelineEntriesFromSqlite(options = {}) {
+    if (!this._stateStore || this._preferSqliteReads !== true) {
+      return null;
+    }
+    try {
+      const rows = await this._stateStore.listTimelineSnapshotIndex({
+        trigger: options.trigger,
+        snapshotId: options.snapshotId,
+        limit: options.limit
+      });
+      if (!Array.isArray(rows) || rows.length === 0) {
+        return [];
+      }
+      return rows.map((row) => this._normalizeTimelineIndexedEntry(row));
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  async _readTimelineEntriesFromFile(options = {}) {
+    const index = await this._readIndex();
+    const trigger = `${options.trigger || ''}`.trim();
+    const snapshotId = safeSnapshotId(options.snapshotId);
+    const limit = normalizePositiveInteger(options.limit, 20, 1000);
+
+    let snapshots = Array.isArray(index.snapshots) ? [...index.snapshots] : [];
+    if (trigger) {
+      snapshots = snapshots.filter((item) => `${item.trigger || ''}`.trim() === trigger);
+    }
+    if (snapshotId) {
+      snapshots = snapshots.filter((item) => `${item.snapshot_id || ''}`.trim() === snapshotId);
+    }
+    if (limit > 0) {
+      snapshots = snapshots.slice(0, limit);
+    }
+    return snapshots.map((item) => this._normalizeTimelineIndexedEntry(item));
+  }
+
+  async _readTimelineEntriesForRead(options = {}) {
+    const sqliteEntries = await this._readTimelineEntriesFromSqlite(options);
+    if (Array.isArray(sqliteEntries) && sqliteEntries.length > 0) {
+      return {
+        source: 'sqlite',
+        entries: sqliteEntries
+      };
+    }
+    const fileEntries = await this._readTimelineEntriesFromFile(options);
+    return {
+      source: 'file',
+      entries: fileEntries
+    };
+  }
+
+  async _resolveTimelineEntryBySnapshotId(snapshotId) {
+    const resolved = await this._resolveTimelineEntryBySnapshotIdWithSource(snapshotId);
+    return resolved.entry;
+  }
+
+  async _resolveTimelineEntryBySnapshotIdWithSource(snapshotId) {
+    const normalizedId = safeSnapshotId(snapshotId);
+    if (!normalizedId) {
+      return {
+        source: 'file',
+        entry: null
+      };
+    }
+    const fromSqlite = await this._readTimelineEntriesFromSqlite({
+      snapshotId: normalizedId,
+      limit: 1
+    });
+    if (Array.isArray(fromSqlite) && fromSqlite.length > 0) {
+      return {
+        source: 'sqlite',
+        entry: fromSqlite[0]
+      };
+    }
+    const fromFile = await this._readTimelineEntriesFromFile({
+      snapshotId: normalizedId,
+      limit: 1
+    });
+    return {
+      source: 'file',
+      entry: Array.isArray(fromFile) && fromFile.length > 0 ? fromFile[0] : null
+    };
+  }
+
+  async _syncTimelineIndexEntries(entries = [], source = 'runtime.project-timeline') {
+    if (!this._stateStore || !Array.isArray(entries) || entries.length === 0) {
+      return;
+    }
+    try {
+      await this._stateStore.upsertTimelineSnapshotIndex(entries.map((item) => ({
+        snapshot_id: item.snapshot_id,
+        created_at: item.created_at,
+        trigger: item.trigger,
+        event: item.event,
+        summary: item.summary,
+        scene_id: item.scene_id,
+        session_id: item.session_id,
+        command: item.command,
+        file_count: item.file_count,
+        total_bytes: item.total_bytes,
+        snapshot_path: item.path,
+        git: item.git || {}
+      })), {
+        source
+      });
+    } catch (_error) {
+      // best effort sync, keep file index as source of truth
+    }
+  }
+
+  async _getTimelineIndexConsistency() {
+    const index = await this._readIndex();
+    const fileCount = Array.isArray(index.snapshots) ? index.snapshots.length : 0;
+    let sqliteCount = null;
+    if (this._stateStore) {
+      try {
+        const rows = await this._stateStore.listTimelineSnapshotIndex({ limit: 0 });
+        if (Array.isArray(rows)) {
+          sqliteCount = rows.length;
+        }
+      } catch (_error) {
+        sqliteCount = null;
+      }
+    }
+
+    let status = 'file-only';
+    if (sqliteCount === null) {
+      status = 'sqlite-unavailable';
+    } else if (fileCount === 0 && sqliteCount === 0) {
+      status = 'empty';
+    } else if (fileCount === 0 && sqliteCount > 0) {
+      status = 'sqlite-only';
+    } else if (fileCount > 0 && sqliteCount === 0) {
+      status = 'file-only';
+    } else if (fileCount === sqliteCount) {
+      status = 'aligned';
+    } else if (sqliteCount < fileCount) {
+      status = 'pending-sync';
+    } else if (sqliteCount > fileCount) {
+      status = 'sqlite-ahead';
+    }
+
+    return {
+      file_index_count: fileCount,
+      sqlite_index_count: sqliteCount,
+      status
+    };
+  }
+
   _buildExcludePatterns(configPatterns = []) {
     const defaults = DEFAULT_TIMELINE_CONFIG.exclude_paths;
     return Array.from(new Set([
@@ -560,7 +745,7 @@ class ProjectTimelineStore {
 
 async function captureTimelineCheckpoint(options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
-  const store = dependencies.timelineStore || new ProjectTimelineStore(projectPath, dependencies.fileSystem || fs);
+  const store = dependencies.timelineStore || new ProjectTimelineStore(projectPath, dependencies.fileSystem || fs, dependencies);
 
   try {
     if (options.auto !== false) {

package/lib/runtime/session-store.js

@@ -1,6 +1,7 @@
 const fs = require('fs-extra');
 const path = require('path');
 const { SteeringContract, normalizeToolName } = require('./steering-contract');
+const { getSceStateStore } = require('../state/sce-state-store');
 
 const SESSION_SCHEMA_VERSION = '1.0';
 const SESSION_DIR = path.join('.sce', 'sessions');
@@ -43,12 +44,22 @@ function nextSnapshotId(session) {
 }
 
 class SessionStore {
-  constructor(workspaceRoot, steeringContract = null) {
+  constructor(workspaceRoot, steeringContract = null, options = {}) {
     this._workspaceRoot = workspaceRoot;
     this._sessionsDir = path.join(workspaceRoot, SESSION_DIR);
     this._sessionGovernanceDir = path.join(workspaceRoot, SESSION_GOVERNANCE_DIR);
     this._sceneIndexPath = path.join(this._sessionGovernanceDir, SESSION_SCENE_INDEX_FILE);
     this._steeringContract = steeringContract || new SteeringContract(workspaceRoot);
+    this._fileSystem = options.fileSystem || fs;
+    this._env = options.env || process.env;
+    this._stateStore = options.stateStore || getSceStateStore(workspaceRoot, {
+      fileSystem: this._fileSystem,
+      env: this._env,
+      sqliteModule: options.sqliteModule
+    });
+    this._preferSqliteSceneReads = options.preferSqliteSceneReads !== undefined
+      ? options.preferSqliteSceneReads === true
+      : true;
   }
 
   async startSession(options = {}) {
@@ -61,10 +72,10 @@ class SessionStore {
 
     await this._steeringContract.ensureContract();
     const steeringPayload = await this._steeringContract.buildCompilePayload(tool, agentVersion);
-    await fs.ensureDir(this._sessionsDir);
+    await this._fileSystem.ensureDir(this._sessionsDir);
 
     const sessionPath = this._sessionPath(sessionId);
-    if (await fs.pathExists(sessionPath)) {
+    if (await this._fileSystem.pathExists(sessionPath)) {
       throw new Error(`Session already exists: ${sessionId}`);
     }
 
@@ -161,10 +172,10 @@ class SessionStore {
   }
 
   async listSessions() {
-    if (!await fs.pathExists(this._sessionsDir)) {
+    if (!await this._fileSystem.pathExists(this._sessionsDir)) {
       return [];
     }
-    const entries = await fs.readdir(this._sessionsDir);
+    const entries = await this._fileSystem.readdir(this._sessionsDir);
     const records = [];
     for (const entry of entries) {
       if (!entry.endsWith('.json')) {
@@ -172,7 +183,7 @@ class SessionStore {
       }
       const sessionId = entry.slice(0, -'.json'.length);
       try {
-        const session = await fs.readJson(this._sessionPath(sessionId));
+        const session = await this._fileSystem.readJson(this._sessionPath(sessionId));
         records.push(session);
       } catch (_error) {
         // Ignore unreadable entries.
@@ -542,10 +553,47 @@ class SessionStore {
   }
 
   async listSceneRecords() {
+    const sqliteRecords = await this._readSceneRecordsFromSqlite();
+    if (Array.isArray(sqliteRecords) && sqliteRecords.length > 0) {
+      return sqliteRecords;
+    }
     const sceneIndex = await this._readSceneIndex();
     return Object.values(sceneIndex.scenes || {});
   }
 
+  async getSceneIndexDiagnostics() {
+    const sceneIndex = await this._readSceneIndex();
+    const fileRecords = Object.values(sceneIndex.scenes || {});
+    const sqliteRecords = await this._readSceneRecordsFromSqlite();
+
+    const fileCount = fileRecords.length;
+    const sqliteCount = Array.isArray(sqliteRecords) ? sqliteRecords.length : null;
+
+    let status = 'file-only';
+    if (sqliteCount === null) {
+      status = 'sqlite-unavailable';
+    } else if (fileCount === 0 && sqliteCount === 0) {
+      status = 'empty';
+    } else if (fileCount === 0 && sqliteCount > 0) {
+      status = 'sqlite-only';
+    } else if (fileCount > 0 && sqliteCount === 0) {
+      status = 'file-only';
+    } else if (fileCount === sqliteCount) {
+      status = 'aligned';
+    } else if (sqliteCount < fileCount) {
+      status = 'pending-sync';
+    } else if (sqliteCount > fileCount) {
+      status = 'sqlite-ahead';
+    }
+
+    return {
+      read_preference: this._preferSqliteSceneReads ? 'sqlite' : 'file',
+      file_scene_count: fileCount,
+      sqlite_scene_count: sqliteCount,
+      status
+    };
+  }
+
   async listActiveSceneSessions() {
     const records = await this.listSceneRecords();
     const active = [];
@@ -610,20 +658,20 @@ class SessionStore {
       throw new Error(`Invalid session id: ${ref}`);
     }
     const sessionPath = this._sessionPath(sessionId);
-    if (!await fs.pathExists(sessionPath)) {
+    if (!await this._fileSystem.pathExists(sessionPath)) {
       throw new Error(`Session not found: ${sessionId}`);
     }
-    const session = await fs.readJson(sessionPath);
+    const session = await this._fileSystem.readJson(sessionPath);
     return { sessionId, session };
   }
 
   async _writeSession(sessionId, session) {
-    await fs.ensureDir(this._sessionsDir);
-    await fs.writeJson(this._sessionPath(sessionId), session, { spaces: 2 });
+    await this._fileSystem.ensureDir(this._sessionsDir);
+    await this._fileSystem.writeJson(this._sessionPath(sessionId), session, { spaces: 2 });
   }
 
   async _readSceneIndex() {
-    if (!await fs.pathExists(this._sceneIndexPath)) {
+    if (!await this._fileSystem.pathExists(this._sceneIndexPath)) {
       return {
         schema_version: SESSION_GOVERNANCE_SCHEMA_VERSION,
         updated_at: nowIso(),
@@ -632,7 +680,7 @@ class SessionStore {
     }
 
     try {
-      const payload = await fs.readJson(this._sceneIndexPath);
+      const payload = await this._fileSystem.readJson(this._sceneIndexPath);
       return {
         schema_version: payload && payload.schema_version
           ? payload.schema_version
@@ -659,11 +707,116 @@ class SessionStore {
         ? indexPayload.scenes
         : {}
     };
-    await fs.ensureDir(this._sessionGovernanceDir);
-    await fs.writeJson(this._sceneIndexPath, payload, { spaces: 2 });
+    await this._fileSystem.ensureDir(this._sessionGovernanceDir);
+    await this._fileSystem.writeJson(this._sceneIndexPath, payload, { spaces: 2 });
+    await this._syncSceneIndexToStateStore(payload);
     return payload;
   }
 
+  async _readSceneRecordsFromSqlite() {
+    if (this._preferSqliteSceneReads !== true || !this._stateStore) {
+      return null;
+    }
+    try {
+      const cycles = await this._stateStore.listSceneSessionCycles({ limit: 0 });
+      if (!Array.isArray(cycles) || cycles.length === 0) {
+        return [];
+      }
+      const grouped = new Map();
+      for (const cycle of cycles) {
+        const sceneId = `${cycle.scene_id || ''}`.trim();
+        if (!sceneId) {
+          continue;
+        }
+        if (!grouped.has(sceneId)) {
+          grouped.set(sceneId, []);
+        }
+        grouped.get(sceneId).push({
+          cycle: Number(cycle.cycle || 0),
+          session_id: `${cycle.session_id || ''}`.trim(),
+          status: `${cycle.status || ''}`.trim() || null,
+          started_at: cycle.started_at || null,
+          completed_at: cycle.completed_at || null
+        });
+      }
+
+      const sceneRecords = [];
+      for (const [sceneId, rows] of grouped.entries()) {
+        rows.sort((left, right) => right.cycle - left.cycle);
+        const active = rows.find((item) => item.status === 'active') || null;
+        const completed = rows.find((item) => item.status === 'completed') || null;
+        const lastCycle = rows.length > 0 ? rows[0].cycle : 0;
+
+        sceneRecords.push({
+          scene_id: sceneId,
+          active_session_id: active ? active.session_id : null,
+          active_cycle: active ? active.cycle : null,
+          latest_completed_session_id: completed ? completed.session_id : null,
+          last_cycle: lastCycle,
+          cycles: rows.map((item) => ({
+            cycle: item.cycle,
+            session_id: item.session_id,
+            status: item.status,
+            started_at: item.started_at,
+            completed_at: item.completed_at
+          }))
+        });
+      }
+
+      sceneRecords.sort((left, right) => `${left.scene_id}`.localeCompare(`${right.scene_id}`));
+      return sceneRecords;
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  _flattenSceneCycleRows(indexPayload = {}) {
+    const scenes = indexPayload && typeof indexPayload.scenes === 'object' && indexPayload.scenes
+      ? indexPayload.scenes
+      : {};
+    const records = [];
+    for (const [sceneId, sceneRecord] of Object.entries(scenes)) {
+      const normalizedSceneId = `${sceneId || ''}`.trim();
+      if (!normalizedSceneId) {
+        continue;
+      }
+      const cycles = Array.isArray(sceneRecord && sceneRecord.cycles) ? sceneRecord.cycles : [];
+      for (const cycle of cycles) {
+        const cycleNo = Number.parseInt(`${cycle && cycle.cycle}`, 10);
+        const sessionId = `${cycle && cycle.session_id ? cycle.session_id : ''}`.trim();
+        if (!Number.isFinite(cycleNo) || cycleNo <= 0 || !sessionId) {
+          continue;
+        }
+        records.push({
+          scene_id: normalizedSceneId,
+          cycle: cycleNo,
+          session_id: sessionId,
+          status: `${cycle && cycle.status ? cycle.status : ''}`.trim() || null,
+          started_at: cycle && cycle.started_at ? cycle.started_at : null,
+          completed_at: cycle && cycle.completed_at ? cycle.completed_at : null
+        });
+      }
+    }
+    return records;
+  }
+
+  async _syncSceneIndexToStateStore(indexPayload = {}) {
+    if (!this._stateStore) {
+      return;
+    }
+    try {
+      const records = this._flattenSceneCycleRows(indexPayload);
+      if (records.length === 0) {
+        return;
+      }
+      await this._stateStore.upsertSceneSessionCycles(records, {
+        source: 'runtime.session-store'
+      });
+    } catch (_error) {
+      // best effort sync only
+    }
+  }
+
   _sessionPath(sessionId) {
     return path.join(this._sessionsDir, `${sessionId}.json`);
   }