fraim-hub 2.0.204

package/dist/src/ai-hub/conversation-store.js

@@ -0,0 +1,428 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiHubConversationStore = exports.COMPANY_SCOPE_KEY = exports.MANAGER_SCOPE_KEY = void 0;
+exports.conversationScopeKey = conversationScopeKey;
+exports.migrateConversationStore = migrateConversationStore;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+// Issue #708: reserved, project-independent bucket keys for non-project scopes.
+// They are NOT filesystem paths and must never be passed through path.resolve.
+exports.MANAGER_SCOPE_KEY = '@manager';
+exports.COMPANY_SCOPE_KEY = '@company';
+/**
+ * Issue #708: resolve the conversation store bucket key for a given scope.
+ * - 'manager'/'company' → a stable sentinel key (project-independent home).
+ * - 'project' (or undefined) → the resolved project path (existing behavior).
+ */
+function conversationScopeKey(scope, projectPath) {
+    if (scope === 'manager')
+        return exports.MANAGER_SCOPE_KEY;
+    if (scope === 'company')
+        return exports.COMPANY_SCOPE_KEY;
+    return normalizeConversationKey(projectPath);
+}
+const emptyProjectState = () => ({
+    activeId: null,
+    conversations: [],
+});
+const emptyStoreFile = () => ({
+    version: 1,
+    projects: {},
+});
+function timestampValue(value) {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : 0;
+    if (typeof value === 'string') {
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+        const numeric = Number(value);
+        return Number.isFinite(numeric) ? numeric : 0;
+    }
+    return 0;
+}
+// Issue #708: sentinel scope keys (e.g. '@manager') are stable bucket keys, not paths —
+// pass them through untouched; resolve everything else as a real project path.
+function normalizeConversationKey(key) {
+    if (typeof key === 'string' && (key === exports.MANAGER_SCOPE_KEY || key === exports.COMPANY_SCOPE_KEY)) {
+        return key;
+    }
+    return path_1.default.resolve(key || process.cwd());
+}
+// Retained name for project-path stamping; now sentinel-aware so manager/company
+// records keep their scope key rather than being resolved into cwd/@manager.
+function normalizeProjectPath(projectPath) {
+    return normalizeConversationKey(projectPath);
+}
+// Issue #708: one-time, idempotent migration. Legacy manager/company-invoked runs were
+// stored inside project buckets and distinguished only by the client-side `invokedArea`
+// field. Fold them into the reserved scope buckets (stamping `scope`) so they have a
+// stable, project-independent home. Runs already in a scope bucket are left untouched.
+function migrateScopeBuckets(store) {
+    const projects = {};
+    const ensure = (key) => {
+        if (!projects[key])
+            projects[key] = { activeId: null, conversations: [] };
+        return projects[key];
+    };
+    // Seed existing scope buckets first so their activeId is preserved.
+    for (const [key, state] of Object.entries(store.projects || {})) {
+        if (key === exports.MANAGER_SCOPE_KEY || key === exports.COMPANY_SCOPE_KEY) {
+            ensure(key).conversations.push(...(state.conversations || []));
+            projects[key].activeId = state.activeId ?? null;
+        }
+    }
+    for (const [key, state] of Object.entries(store.projects || {})) {
+        if (key === exports.MANAGER_SCOPE_KEY || key === exports.COMPANY_SCOPE_KEY)
+            continue;
+        const stay = [];
+        for (const conv of (state.conversations || [])) {
+            const scope = conv.scope
+                ?? conv.invokedArea;
+            if (scope === 'manager' || scope === 'company') {
+                const bucketKey = scope === 'manager' ? exports.MANAGER_SCOPE_KEY : exports.COMPANY_SCOPE_KEY;
+                const bucket = ensure(bucketKey);
+                if (!bucket.conversations.some((c) => c && c.id === conv.id)) {
+                    bucket.conversations.push({ ...conv, scope: scope });
+                }
+            }
+            else {
+                stay.push(conv);
+            }
+        }
+        projects[key] = { activeId: state.activeId ?? null, conversations: stay };
+    }
+    return { version: 1, projects };
+}
+// Canonical comparison key for a project path (case-insensitive on win32), matching the
+// convention used by removeProject and the preferences store.
+function canonicalProjectPathKey(value) {
+    const resolved = path_1.default.resolve(value);
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+// How much run history a record carries. Used to decide the winner when the same conversation id
+// exists in two buckets: the copy with real history must never be overwritten by a header-only
+// shell (which is exactly what a mis-filed slim PUT produces).
+function conversationRichness(conv) {
+    const value = conv;
+    const messages = Array.isArray(value?.messages) ? value.messages.length : 0;
+    const events = Array.isArray(value?.events) ? value.events.length : 0;
+    return messages + events;
+}
+// Place a raw conversation into a bucket, deduping by id. When the id already exists, keep the
+// richer copy (more run history); tie-break on newer lastUpdatedAt. Order-independent.
+function placeConversationInBucket(bucket, conv) {
+    const value = conv;
+    const id = value && typeof value.id === 'string' ? value.id : '';
+    if (!id) {
+        bucket.conversations.push(conv);
+        return;
+    }
+    const idx = bucket.conversations.findIndex((entry) => entry && entry.id === id);
+    if (idx < 0) {
+        bucket.conversations.push(conv);
+        return;
+    }
+    const existing = bucket.conversations[idx];
+    const existingScore = conversationRichness(existing);
+    const incomingScore = conversationRichness(conv);
+    if (incomingScore > existingScore) {
+        bucket.conversations[idx] = conv;
+    }
+    else if (incomingScore === existingScore
+        && timestampValue(value?.lastUpdatedAt) > timestampValue(existing.lastUpdatedAt)) {
+        bucket.conversations[idx] = conv;
+    }
+}
+// A conversation's identity is unique only WITHIN a bucket, and a bucket key is a project path.
+// The buggy client PUT path could file a conversation whose own projectPath points at project B
+// into project A's bucket (see docs/rca/hub-conversation-cross-project-leak.md), so the same run
+// appeared under two projects and the mis-filed copy was a header-only shell. This one-time,
+// idempotent, read-time migration relocates every project-scoped record back to the bucket that
+// matches its own projectPath, deduping so the copy with real run history wins. A bucket activeId
+// that pointed at a relocated record is cleared. Sentinel scope buckets (@manager/@company)
+// legitimately hold records whose projectPath points at a project, so they are left untouched.
+function migrateProjectBuckets(store) {
+    const projects = {};
+    const ensure = (key) => {
+        if (!projects[key])
+            projects[key] = { activeId: null, conversations: [] };
+        return projects[key];
+    };
+    // Preserve every existing bucket key and its activeId up front.
+    for (const [key, state] of Object.entries(store.projects || {})) {
+        ensure(key).activeId = state.activeId ?? null;
+    }
+    for (const [bucketKey, state] of Object.entries(store.projects || {})) {
+        const isSentinel = bucketKey === exports.MANAGER_SCOPE_KEY || bucketKey === exports.COMPANY_SCOPE_KEY;
+        for (const conv of (state.conversations || [])) {
+            if (!conv || typeof conv !== 'object')
+                continue;
+            const scope = conv.scope
+                ?? conv.invokedArea;
+            const ownPath = typeof conv.projectPath === 'string'
+                ? conv.projectPath
+                : '';
+            const mismatched = !isSentinel
+                && scope !== 'manager' && scope !== 'company'
+                && ownPath.length > 0
+                && canonicalProjectPathKey(ownPath) !== canonicalProjectPathKey(bucketKey);
+            if (!mismatched) {
+                placeConversationInBucket(ensure(bucketKey), conv);
+                continue;
+            }
+            // Relocate to the record's own project bucket.
+            placeConversationInBucket(ensure(path_1.default.resolve(ownPath)), conv);
+        }
+    }
+    // Any activeId that no longer resolves to a conversation in its bucket (because that record was
+    // relocated out) is stale — clear it so a project never points at another project's run.
+    for (const state of Object.values(projects)) {
+        if (state.activeId && !state.conversations.some((entry) => entry && entry.id === state.activeId)) {
+            state.activeId = null;
+        }
+    }
+    return { version: 1, projects };
+}
+// The full on-read migration pipeline, exported so a one-off maintenance/cleanup pass can heal an
+// existing store file through the EXACT same code path the store uses at runtime (rather than a
+// duplicated, drift-prone reimplementation). Operates on raw records, so it never drops a record
+// via normalization.
+function migrateConversationStore(store) {
+    return migrateProjectBuckets(migrateScopeBuckets(store));
+}
+function sameStoreMetadata(left, right) {
+    return left.ctimeMs === right.ctimeMs
+        && left.mtimeMs === right.mtimeMs
+        && left.size === right.size;
+}
+function cloneJsonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneJsonValue(entry));
+    }
+    if (value && typeof value === 'object') {
+        const cloned = {};
+        for (const [key, entry] of Object.entries(value)) {
+            cloned[key] = cloneJsonValue(entry);
+        }
+        return cloned;
+    }
+    return value;
+}
+function cloneConversationRecord(record) {
+    return cloneJsonValue(record);
+}
+function cloneProjectState(state) {
+    return {
+        activeId: state?.activeId ?? null,
+        conversations: Array.isArray(state?.conversations)
+            ? state.conversations.map((record) => cloneConversationRecord(record))
+            : [],
+    };
+}
+function cloneStoreFile(store) {
+    const projects = {};
+    for (const [key, state] of Object.entries(store.projects || {})) {
+        projects[key] = cloneProjectState(state);
+    }
+    return { version: 1, projects };
+}
+function normalizeConversation(projectPath, raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const value = raw;
+    if (typeof value.id !== 'string' || value.id.length === 0)
+        return null;
+    if (typeof value.title !== 'string')
+        return null;
+    if (typeof value.jobId !== 'string')
+        return null;
+    if (value.agentName !== 'codex' && value.agentName !== 'claude' && value.agentName !== 'gemini')
+        return null;
+    if (value.status !== 'running' && value.status !== 'completed' && value.status !== 'failed')
+        return null;
+    return {
+        ...value,
+        id: value.id,
+        projectPath: normalizeProjectPath(typeof value.projectPath === 'string' ? value.projectPath : projectPath),
+        title: value.title,
+        jobId: value.jobId,
+        agentName: value.agentName,
+        status: value.status,
+        createdAt: value.createdAt ?? new Date().toISOString(),
+        lastUpdatedAt: value.lastUpdatedAt ?? value.createdAt ?? new Date().toISOString(),
+    };
+}
+function normalizeProjectState(projectPath, raw) {
+    if (!raw || typeof raw !== 'object')
+        return emptyProjectState();
+    const value = raw;
+    const conversations = Array.isArray(value.conversations)
+        ? value.conversations.map((entry) => normalizeConversation(projectPath, entry)).filter((entry) => Boolean(entry))
+        : [];
+    const activeId = typeof value.activeId === 'string' && conversations.some((entry) => entry.id === value.activeId)
+        ? value.activeId
+        : null;
+    return { activeId, conversations };
+}
+class AiHubConversationStore {
+    constructor(stateFilePath = path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'ai-hub-conversations.json')) {
+        this.stateFilePath = stateFilePath;
+        this.cachedStore = null;
+    }
+    listProjectPaths() {
+        const state = this.readStore();
+        return Object.keys(state.projects || {}).map((projectPath) => normalizeProjectPath(projectPath));
+    }
+    loadProject(projectPath) {
+        const state = this.readStore();
+        const normalizedProjectPath = normalizeProjectPath(projectPath);
+        return cloneProjectState(normalizeProjectState(normalizedProjectPath, state.projects[normalizedProjectPath]));
+    }
+    // Issue #719: delete a project's KEY from the store entirely. Writing an empty
+    // conversation list is not enough — knownProjects re-derives a project from
+    // every stored key (listProjectPaths), so removal must drop the key itself.
+    // Sentinel scope buckets (@manager/@company) are not projects and never removable.
+    removeProject(projectPath) {
+        if (projectPath === exports.MANAGER_SCOPE_KEY || projectPath === exports.COMPANY_SCOPE_KEY)
+            return false;
+        const canonicalKey = (value) => {
+            const resolved = path_1.default.resolve(value);
+            return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+        };
+        const target = canonicalKey(projectPath);
+        const state = cloneStoreFile(this.readStore());
+        let removed = false;
+        for (const key of Object.keys(state.projects)) {
+            if (key === exports.MANAGER_SCOPE_KEY || key === exports.COMPANY_SCOPE_KEY)
+                continue;
+            if (canonicalKey(key) === target) {
+                delete state.projects[key];
+                removed = true;
+            }
+        }
+        if (removed)
+            this.writeStore(state);
+        return removed;
+    }
+    replaceProject(projectPath, next) {
+        const normalizedProjectPath = normalizeProjectPath(projectPath);
+        const normalized = normalizeProjectState(normalizedProjectPath, next);
+        const state = cloneStoreFile(this.readStore());
+        state.projects[normalizedProjectPath] = normalized;
+        this.writeStore(state);
+        return cloneProjectState(normalized);
+    }
+    upsertConversation(projectPath, conversation, activeId) {
+        const normalizedProjectPath = normalizeProjectPath(projectPath);
+        const normalizedConversation = normalizeConversation(normalizedProjectPath, conversation);
+        if (!normalizedConversation) {
+            return this.loadProject(normalizedProjectPath);
+        }
+        const current = this.loadProject(normalizedProjectPath);
+        const idx = current.conversations.findIndex((entry) => entry.id === normalizedConversation.id);
+        if (idx >= 0) {
+            const existing = current.conversations[idx];
+            if (timestampValue(normalizedConversation.lastUpdatedAt) < timestampValue(existing.lastUpdatedAt)) {
+                return current;
+            }
+            current.conversations[idx] = normalizedConversation;
+        }
+        else {
+            current.conversations.unshift(normalizedConversation);
+        }
+        current.activeId = activeId === undefined ? current.activeId : activeId;
+        if (current.activeId && !current.conversations.some((entry) => entry.id === current.activeId)) {
+            current.activeId = null;
+        }
+        return this.replaceProject(normalizedProjectPath, current);
+    }
+    patchConversation(projectPath, conversationId, patch) {
+        const normalizedProjectPath = normalizeProjectPath(projectPath);
+        const current = this.loadProject(normalizedProjectPath);
+        const idx = current.conversations.findIndex((entry) => entry.id === conversationId);
+        if (idx < 0) {
+            const candidate = normalizeConversation(normalizedProjectPath, {
+                ...patch,
+                id: conversationId,
+                projectPath: normalizedProjectPath,
+            });
+            if (candidate) {
+                current.conversations.unshift(candidate);
+                return this.replaceProject(normalizedProjectPath, current);
+            }
+            return current;
+        }
+        const existing = current.conversations[idx];
+        if (patch.lastUpdatedAt !== undefined
+            && timestampValue(patch.lastUpdatedAt) < timestampValue(existing.lastUpdatedAt)) {
+            return current;
+        }
+        current.conversations[idx] = {
+            ...existing,
+            ...patch,
+            id: existing.id,
+            projectPath: normalizedProjectPath,
+            agentName: patch.agentName || existing.agentName,
+            lastUpdatedAt: patch.lastUpdatedAt ?? new Date().toISOString(),
+        };
+        return this.replaceProject(normalizedProjectPath, current);
+    }
+    readStore() {
+        const metadata = this.readStoreMetadata();
+        if (!metadata) {
+            this.cachedStore = null;
+            return emptyStoreFile();
+        }
+        if (this.cachedStore && sameStoreMetadata(this.cachedStore.metadata, metadata)) {
+            return this.cachedStore.store;
+        }
+        try {
+            const raw = JSON.parse(fs_1.default.readFileSync(this.stateFilePath, 'utf8'));
+            if (raw.version !== 1 || !raw.projects || typeof raw.projects !== 'object') {
+                const empty = emptyStoreFile();
+                this.cachedStore = { metadata, store: empty };
+                return empty;
+            }
+            // Issue #708: fold legacy manager/company-invoked runs into scope buckets on read, then
+            // relocate any project-scoped record mis-filed under the wrong project bucket back to its
+            // own project (see docs/rca/hub-conversation-cross-project-leak.md).
+            const migrated = migrateConversationStore({ version: 1, projects: raw.projects });
+            this.cachedStore = { metadata, store: migrated };
+            return migrated;
+        }
+        catch {
+            const empty = emptyStoreFile();
+            this.cachedStore = { metadata, store: empty };
+            return empty;
+        }
+    }
+    writeStore(store) {
+        fs_1.default.mkdirSync(path_1.default.dirname(this.stateFilePath), { recursive: true });
+        const tempPath = `${this.stateFilePath}.${process.pid}.tmp`;
+        fs_1.default.writeFileSync(tempPath, JSON.stringify(store, null, 2), 'utf8');
+        fs_1.default.renameSync(tempPath, this.stateFilePath);
+        const metadata = this.readStoreMetadata();
+        this.cachedStore = metadata ? { metadata, store: cloneStoreFile(store) } : null;
+    }
+    readStoreMetadata() {
+        try {
+            const stat = fs_1.default.statSync(this.stateFilePath);
+            if (!stat.isFile())
+                return null;
+            return {
+                ctimeMs: stat.ctimeMs,
+                mtimeMs: stat.mtimeMs,
+                size: stat.size,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.AiHubConversationStore = AiHubConversationStore;