@plusplusoneplusplus/coc 1.0.1 → 1.0.3

package/node_modules/@plusplusoneplusplus/forge/dist/file-process-store.js

@@ -0,0 +1,935 @@
+"use strict";
+/**
+ * File-based ProcessStore Implementation
+ *
+ * Persistent AI process storage using JSON files in a configurable data directory.
+ * Per-workspace subdirectory layout: repos/<workspaceId>/processes/index.json + repos/<workspaceId>/processes/<id>.json
+ * Cross-workspace ID lookups via index scan across per-workspace index.json files.
+ * Empty workspaceId maps to repos/_default/processes/.
+ *
+ * No VS Code dependencies - designed for the standalone pipeline server.
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileProcessStore = void 0;
+exports.getDefaultDataDir = getDefaultDataDir;
+exports.ensureDataDir = ensureDataDir;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const events_1 = require("events");
+const process_types_1 = require("./ai/process-types");
+const retry_1 = require("./runtime/retry");
+const logger_1 = require("./logger");
+/** Returns ~/.coc/ with ~ expanded via os.homedir(), overridden by COC_DATA_DIR env var */
+function getDefaultDataDir() {
+    return process.env.COC_DATA_DIR ?? path.join(os.homedir(), '.coc');
+}
+/** Creates directory (and parents) if it doesn't exist. Returns resolved path. */
+async function ensureDataDir(dirPath) {
+    const resolved = path.resolve(dirPath);
+    await fs.mkdir(resolved, { recursive: true });
+    return resolved;
+}
+class FileProcessStore {
+    constructor(options) {
+        this.emitters = new Map();
+        this.flushHandlers = new Map();
+        this.dataDir = options?.dataDir ?? getDefaultDataDir();
+        this.maxProcesses = options?.maxProcesses ?? 500;
+        this.processesDir = path.join(this.dataDir, 'repos');
+        this.workspacesPath = path.join(this.dataDir, 'workspaces.json');
+        this.wikisPath = path.join(this.dataDir, 'wikis.json');
+        this.writeQueue = Promise.resolve();
+        this.onPrune = options?.onPrune;
+    }
+    // --- Per-workspace directory helpers ---
+    workspaceDirFor(workspaceId) {
+        return path.join(this.processesDir, workspaceId || '_default', 'processes');
+    }
+    indexPathFor(workspaceId) {
+        return path.join(this.workspaceDirFor(workspaceId), 'index.json');
+    }
+    getProcessFilePath(workspaceId, processId) {
+        return path.join(this.workspaceDirFor(workspaceId), this.sanitizeId(processId) + '.json');
+    }
+    // --- Pruned bucket helpers (processes/pruned/YYYY-MM/) ---
+    prunedRootFor(workspaceId) {
+        return path.join(this.workspaceDirFor(workspaceId), 'pruned');
+    }
+    prunedBucketFor(workspaceId, startTime) {
+        const bucket = new Date(startTime).toISOString().slice(0, 7);
+        return path.join(this.prunedRootFor(workspaceId), bucket);
+    }
+    prunedBucketIndexPathFor(workspaceId, startTime) {
+        return path.join(this.prunedBucketFor(workspaceId, startTime), 'index.json');
+    }
+    getPrunedProcessFilePath(workspaceId, processId, startTime) {
+        return path.join(this.prunedBucketFor(workspaceId, startTime), this.sanitizeId(processId) + '.json');
+    }
+    async readPrunedBucketIndex(workspaceId, startTime) {
+        try {
+            const data = await fs.readFile(this.prunedBucketIndexPathFor(workspaceId, startTime), 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return [];
+        }
+    }
+    async writePrunedBucketIndex(workspaceId, startTime, entries) {
+        const bucketDir = this.prunedBucketFor(workspaceId, startTime);
+        await ensureDataDir(bucketDir);
+        const indexPath = this.prunedBucketIndexPathFor(workspaceId, startTime);
+        const tmpPath = indexPath + '.tmp';
+        await this.retryAtomicWrite(tmpPath, async () => {
+            await fs.writeFile(tmpPath, JSON.stringify(entries, null, 2), 'utf-8');
+            await fs.rename(tmpPath, indexPath);
+        });
+    }
+    // --- Process CRUD ---
+    async addProcess(process) {
+        await this.enqueueWrite(async () => {
+            const workspaceId = process.metadata?.workspaceId ?? '';
+            await ensureDataDir(this.workspaceDirFor(workspaceId));
+            const entry = {
+                workspaceId,
+                process: (0, process_types_1.serializeProcess)(process)
+            };
+            // Write per-process file first (orphan on crash is harmless)
+            await this.writeProcessFile(workspaceId, process.id, entry);
+            // Upsert into workspace index, prune, then write back
+            const index = await this.readIndex(workspaceId);
+            const existingIdx = index.findIndex(e => e.id === process.id);
+            if (existingIdx >= 0) {
+                index[existingIdx] = this.toIndexEntry(entry);
+            }
+            else {
+                index.push(this.toIndexEntry(entry));
+            }
+            const pruned = await this.pruneWorkspaceIfNeeded(workspaceId, index);
+            await this.writeIndex(workspaceId, pruned);
+        });
+        this.onProcessChange?.({ type: 'process-added', process });
+    }
+    async getProcess(id, workspaceId) {
+        if (workspaceId !== undefined) {
+            // Direct path — workspaceId hint provided
+            const entry = await this.readProcessFile(workspaceId, id);
+            if (!entry)
+                return undefined;
+            const result = (0, process_types_1.deserializeProcess)(entry.process);
+            result.dataFilePath = this.getProcessFilePath(workspaceId, id);
+            return result;
+        }
+        // Scan workspace index files to find owning workspace
+        const wsId = await this.findWorkspaceIdForProcess(id);
+        if (wsId === undefined)
+            return undefined;
+        const entry = await this.readProcessFile(wsId, id);
+        if (!entry)
+            return undefined;
+        const result = (0, process_types_1.deserializeProcess)(entry.process);
+        result.dataFilePath = this.getProcessFilePath(wsId, id);
+        return result;
+    }
+    async getAllProcesses(filter) {
+        if (filter?.workspaceId) {
+            let indexEntries = await this.readIndex(filter.workspaceId);
+            indexEntries = this.applyIndexFilters(indexEntries, filter);
+            if (filter.limit !== undefined) {
+                const offset = filter.offset ?? 0;
+                indexEntries = indexEntries.slice(offset, offset + filter.limit);
+            }
+            const processes = [];
+            for (const ie of indexEntries) {
+                const entry = await this.readProcessFile(filter.workspaceId, ie.id);
+                if (entry) {
+                    processes.push((0, process_types_1.deserializeProcess)(entry.process));
+                }
+            }
+            return this.applyExclude(processes, filter?.exclude);
+        }
+        // Aggregate across all workspace subdirs
+        let allIndexEntries = await this.aggregateAllIndices();
+        allIndexEntries = this.applyIndexFilters(allIndexEntries, filter);
+        if (filter?.limit !== undefined) {
+            const offset = filter.offset ?? 0;
+            allIndexEntries = allIndexEntries.slice(offset, offset + filter.limit);
+        }
+        const processes = [];
+        for (const ie of allIndexEntries) {
+            const entry = await this.readProcessFile(ie.workspaceId, ie.id);
+            if (entry) {
+                processes.push((0, process_types_1.deserializeProcess)(entry.process));
+            }
+        }
+        return this.applyExclude(processes, filter?.exclude);
+    }
+    async getProcessSummaries(filter) {
+        if (filter?.workspaceId) {
+            let indexEntries = await this.readIndex(filter.workspaceId);
+            indexEntries = this.applyIndexFilters(indexEntries, filter);
+            const total = indexEntries.length;
+            if (filter.limit !== undefined) {
+                const offset = filter.offset ?? 0;
+                indexEntries = indexEntries.slice(offset, offset + filter.limit);
+            }
+            return { entries: indexEntries, total };
+        }
+        let allIndexEntries = await this.aggregateAllIndices();
+        allIndexEntries = this.applyIndexFilters(allIndexEntries, filter);
+        const total = allIndexEntries.length;
+        if (filter?.limit !== undefined) {
+            const offset = filter.offset ?? 0;
+            allIndexEntries = allIndexEntries.slice(offset, offset + filter.limit);
+        }
+        return { entries: allIndexEntries, total };
+    }
+    applyIndexFilters(indexEntries, filter) {
+        let entries = indexEntries;
+        if (filter?.workspaceId) {
+            entries = entries.filter(e => e.workspaceId === filter.workspaceId);
+        }
+        if (filter?.parentProcessId) {
+            entries = entries.filter(e => e.parentProcessId === filter.parentProcessId);
+        }
+        if (filter?.status) {
+            const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+            entries = entries.filter(e => statuses.includes(e.status));
+        }
+        if (filter?.type) {
+            entries = entries.filter(e => e.type === filter.type);
+        }
+        if (filter?.since) {
+            const sinceTime = filter.since.getTime();
+            entries = entries.filter(e => new Date(e.startTime).getTime() >= sinceTime);
+        }
+        return entries;
+    }
+    /** Strip fields specified by `exclude` from loaded process objects. */
+    applyExclude(processes, exclude) {
+        if (!exclude || exclude.length === 0) {
+            return processes;
+        }
+        const stripConversation = exclude.includes('conversation');
+        const stripToolCalls = exclude.includes('toolCalls');
+        if (!stripConversation && !stripToolCalls) {
+            return processes;
+        }
+        return processes.map(p => {
+            if (stripConversation) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { conversationTurns, fullPrompt, result, ...rest } = p;
+                return rest;
+            }
+            if (stripToolCalls && p.conversationTurns) {
+                return {
+                    ...p,
+                    conversationTurns: p.conversationTurns.map(turn => {
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        const { toolCalls, ...rest } = turn;
+                        return rest;
+                    }),
+                };
+            }
+            return p;
+        });
+    }
+    /** Returns true when filter contains any field that narrows which processes match (beyond workspaceId). */
+    hasContentFilters(filter) {
+        return !!(filter?.parentProcessId || filter?.status || filter?.type || filter?.since);
+    }
+    async updateProcess(id, updates) {
+        let updated;
+        await this.enqueueWrite(async () => {
+            const workspaceId = await this.findWorkspaceIdForProcess(id);
+            if (workspaceId === undefined) {
+                return;
+            }
+            const entry = await this.readProcessFile(workspaceId, id);
+            if (!entry) {
+                return;
+            }
+            const existing = (0, process_types_1.deserializeProcess)(entry.process);
+            const merged = { ...existing, ...updates };
+            const newEntry = {
+                workspaceId: merged.metadata?.workspaceId ?? entry.workspaceId,
+                process: (0, process_types_1.serializeProcess)(merged)
+            };
+            await this.writeProcessFile(workspaceId, id, newEntry);
+            // Update workspace index entry
+            const index = await this.readIndex(workspaceId);
+            const idx = index.findIndex(e => e.id === id);
+            if (idx !== -1) {
+                index[idx] = this.toIndexEntry(newEntry);
+                await this.writeIndex(workspaceId, index);
+            }
+            updated = merged;
+        });
+        if (updated) {
+            this.onProcessChange?.({ type: 'process-updated', process: updated });
+        }
+    }
+    /**
+     * Atomically append a conversation turn inside the write queue.
+     *
+     * Reads the current process, optionally filters out streaming assistant turns,
+     * calls makeTurn with the computed index, appends the turn, and writes back —
+     * all inside a single enqueueWrite slot. This prevents lost-update races between
+     * the api-handler (user turns) and the follow-up executor (assistant turns).
+     */
+    async appendConversationTurn(processId, makeTurn, options) {
+        let appendResult;
+        let updatedProcess;
+        await this.enqueueWrite(async () => {
+            const workspaceId = await this.findWorkspaceIdForProcess(processId);
+            if (workspaceId === undefined) {
+                return;
+            }
+            const entry = await this.readProcessFile(workspaceId, processId);
+            if (!entry) {
+                return;
+            }
+            const existing = (0, process_types_1.deserializeProcess)(entry.process);
+            let turns = existing.conversationTurns ?? [];
+            if (options?.filterStreaming) {
+                turns = turns.filter(t => !(t.role === 'assistant' && t.streaming));
+            }
+            const turn = makeTurn(turns.length);
+            const allTurns = [...turns, turn];
+            const extraUpdates = typeof options?.additionalUpdates === 'function'
+                ? options.additionalUpdates(existing)
+                : (options?.additionalUpdates ?? {});
+            const merged = { ...existing, ...extraUpdates, conversationTurns: allTurns };
+            const newEntry = {
+                workspaceId: merged.metadata?.workspaceId ?? entry.workspaceId,
+                process: (0, process_types_1.serializeProcess)(merged),
+            };
+            await this.writeProcessFile(workspaceId, processId, newEntry);
+            const index = await this.readIndex(workspaceId);
+            const idx = index.findIndex(e => e.id === processId);
+            if (idx !== -1) {
+                index[idx] = this.toIndexEntry(newEntry);
+                await this.writeIndex(workspaceId, index);
+            }
+            appendResult = { turn, allTurns };
+            updatedProcess = merged;
+        });
+        if (updatedProcess) {
+            this.onProcessChange?.({ type: 'process-updated', process: updatedProcess });
+        }
+        return appendResult;
+    }
+    async removeProcess(id) {
+        let removed;
+        await this.enqueueWrite(async () => {
+            const workspaceId = await this.findWorkspaceIdForProcess(id);
+            if (workspaceId === undefined) {
+                return;
+            }
+            const entry = await this.readProcessFile(workspaceId, id);
+            if (!entry) {
+                return;
+            }
+            removed = (0, process_types_1.deserializeProcess)(entry.process);
+            await this.deleteProcessFile(workspaceId, id);
+            const index = await this.readIndex(workspaceId);
+            const filtered = index.filter(e => e.id !== id);
+            await this.writeIndex(workspaceId, filtered);
+        });
+        if (removed) {
+            this.onProcessChange?.({ type: 'process-removed', process: removed });
+        }
+    }
+    async clearProcesses(filter) {
+        let count = 0;
+        await this.enqueueWrite(async () => {
+            const hasExtra = this.hasContentFilters(filter);
+            const workspaceDirs = filter?.workspaceId
+                ? [filter.workspaceId]
+                : await this.listWorkspaceDirs();
+            await Promise.all(workspaceDirs.map(async (wsId) => {
+                if (!hasExtra) {
+                    // Fast path: wipe entire workspace dir
+                    const index = await this.readIndex(wsId);
+                    const allIds = index.map(e => e.id);
+                    await Promise.all([
+                        ...allIds.map(id => this.deleteProcessFile(wsId, id)),
+                        fs.unlink(this.indexPathFor(wsId)).catch(() => { }),
+                    ]);
+                    try {
+                        await fs.rmdir(this.workspaceDirFor(wsId));
+                    }
+                    catch { /* best effort */ }
+                    count += allIds.length;
+                }
+                else {
+                    // Filter-based path
+                    const index = await this.readIndex(wsId);
+                    const remaining = [];
+                    const toDelete = [];
+                    for (const ie of index) {
+                        let match = true;
+                        if (match && filter?.parentProcessId) {
+                            match = ie.parentProcessId === filter.parentProcessId;
+                        }
+                        if (match && filter?.status) {
+                            const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+                            match = statuses.includes(ie.status);
+                        }
+                        if (match && filter?.type) {
+                            match = ie.type === filter.type;
+                        }
+                        if (match && filter?.since) {
+                            match = new Date(ie.startTime).getTime() >= filter.since.getTime();
+                        }
+                        if (match) {
+                            toDelete.push(ie.id);
+                        }
+                        else {
+                            remaining.push(ie);
+                        }
+                    }
+                    await Promise.all(toDelete.map(id => this.deleteProcessFile(wsId, id)));
+                    // Remove workspace dir when it becomes empty (only in cross-workspace scan)
+                    if (remaining.length === 0 && !filter?.workspaceId) {
+                        await fs.unlink(this.indexPathFor(wsId)).catch(() => { });
+                        try {
+                            await fs.rmdir(this.workspaceDirFor(wsId));
+                        }
+                        catch { /* best effort */ }
+                    }
+                    else {
+                        await this.writeIndex(wsId, remaining);
+                    }
+                    count += toDelete.length;
+                }
+            }));
+        });
+        this.onProcessChange?.({ type: 'processes-cleared' });
+        return count;
+    }
+    async registerWorkspace(workspace) {
+        await this.enqueueWrite(async () => {
+            await ensureDataDir(this.dataDir);
+            const workspaces = await this.readWorkspaces();
+            const idx = workspaces.findIndex(w => w.id === workspace.id);
+            if (idx >= 0) {
+                workspaces[idx] = { ...workspaces[idx], ...workspace };
+            }
+            else {
+                workspaces.push(workspace);
+            }
+            await this.writeWorkspaces(workspaces);
+        });
+    }
+    async getWorkspaces() {
+        return this.readWorkspaces();
+    }
+    async removeWorkspace(id) {
+        let found = false;
+        await this.enqueueWrite(async () => {
+            const workspaces = await this.readWorkspaces();
+            const idx = workspaces.findIndex(w => w.id === id);
+            if (idx >= 0) {
+                workspaces.splice(idx, 1);
+                await this.writeWorkspaces(workspaces);
+                found = true;
+            }
+        });
+        return found;
+    }
+    async updateWorkspace(id, updates) {
+        let updated;
+        await this.enqueueWrite(async () => {
+            const workspaces = await this.readWorkspaces();
+            const idx = workspaces.findIndex(w => w.id === id);
+            if (idx >= 0) {
+                if (updates.name !== undefined) {
+                    workspaces[idx].name = updates.name;
+                }
+                if (updates.rootPath !== undefined) {
+                    workspaces[idx].rootPath = updates.rootPath;
+                }
+                if (updates.color !== undefined) {
+                    workspaces[idx].color = updates.color;
+                }
+                if (updates.remoteUrl !== undefined) {
+                    workspaces[idx].remoteUrl = updates.remoteUrl;
+                }
+                if ('enabledMcpServers' in updates) {
+                    workspaces[idx].enabledMcpServers = updates.enabledMcpServers;
+                }
+                if ('disabledSkills' in updates) {
+                    workspaces[idx].disabledSkills = updates.disabledSkills;
+                }
+                if ('extraSkillFolders' in updates) {
+                    workspaces[idx].extraSkillFolders = updates.extraSkillFolders;
+                }
+                updated = { ...workspaces[idx] };
+                await this.writeWorkspaces(workspaces);
+            }
+        });
+        return updated;
+    }
+    // --- Wiki CRUD ---
+    async registerWiki(wiki) {
+        await this.enqueueWrite(async () => {
+            await ensureDataDir(this.dataDir);
+            const wikis = await this.readWikis();
+            const idx = wikis.findIndex(w => w.id === wiki.id);
+            if (idx >= 0) {
+                wikis[idx] = wiki;
+            }
+            else {
+                wikis.push(wiki);
+            }
+            await this.writeWikis(wikis);
+        });
+    }
+    async getWikis() {
+        return this.readWikis();
+    }
+    async removeWiki(id) {
+        let found = false;
+        await this.enqueueWrite(async () => {
+            const wikis = await this.readWikis();
+            const idx = wikis.findIndex(w => w.id === id);
+            if (idx >= 0) {
+                wikis.splice(idx, 1);
+                await this.writeWikis(wikis);
+                found = true;
+            }
+        });
+        return found;
+    }
+    async updateWiki(id, updates) {
+        let updated;
+        await this.enqueueWrite(async () => {
+            const wikis = await this.readWikis();
+            const idx = wikis.findIndex(w => w.id === id);
+            if (idx >= 0) {
+                if (updates.name !== undefined) {
+                    wikis[idx].name = updates.name;
+                }
+                if (updates.wikiDir !== undefined) {
+                    wikis[idx].wikiDir = updates.wikiDir;
+                }
+                if (updates.repoPath !== undefined) {
+                    wikis[idx].repoPath = updates.repoPath;
+                }
+                if (updates.color !== undefined) {
+                    wikis[idx].color = updates.color;
+                }
+                if (updates.aiEnabled !== undefined) {
+                    wikis[idx].aiEnabled = updates.aiEnabled;
+                }
+                if (updates.registeredAt !== undefined) {
+                    wikis[idx].registeredAt = updates.registeredAt;
+                }
+                updated = { ...wikis[idx] };
+                await this.writeWikis(wikis);
+            }
+        });
+        return updated;
+    }
+    // --- Admin: bulk clear & stats ---
+    async clearAllWorkspaces() {
+        let count = 0;
+        await this.enqueueWrite(async () => {
+            const workspaces = await this.readWorkspaces();
+            count = workspaces.length;
+            if (count > 0) {
+                await this.writeWorkspaces([]);
+            }
+        });
+        return count;
+    }
+    async clearAllWikis() {
+        let count = 0;
+        await this.enqueueWrite(async () => {
+            const wikis = await this.readWikis();
+            count = wikis.length;
+            if (count > 0) {
+                await this.writeWikis([]);
+            }
+        });
+        return count;
+    }
+    async getStorageStats() {
+        // Use getProcessSummaries() instead of getAllProcesses() to avoid reading every process file
+        const [summaries, wikis, workspaceDirIds] = await Promise.all([
+            this.getProcessSummaries(),
+            this.getWikis(),
+            this.listWorkspaceDirs(),
+        ]);
+        // Stat meta files in parallel
+        const metaSizes = await Promise.all([this.workspacesPath, this.wikisPath].map(async (filePath) => {
+            try {
+                const stat = await fs.stat(filePath);
+                return stat.size;
+            }
+            catch {
+                return 0;
+            }
+        }));
+        let storageSize = metaSizes.reduce((sum, size) => sum + size, 0);
+        // Sum file sizes in each workspace dir
+        try {
+            for (const wsId of workspaceDirIds) {
+                const wsDir = this.workspaceDirFor(wsId);
+                try {
+                    const entries = await fs.readdir(wsDir);
+                    const sizes = await Promise.all(entries.map(async (entry) => {
+                        try {
+                            const stat = await fs.stat(path.join(wsDir, entry));
+                            return stat.isFile() ? stat.size : 0;
+                        }
+                        catch {
+                            return 0;
+                        }
+                    }));
+                    storageSize += sizes.reduce((sum, size) => sum + size, 0);
+                }
+                catch {
+                    // workspace dir may not exist
+                }
+            }
+        }
+        catch {
+            // processesDir may not exist yet
+        }
+        return {
+            totalProcesses: summaries.total,
+            totalWorkspaces: workspaceDirIds.length,
+            totalWikis: wikis.length,
+            storageSize,
+        };
+    }
+    /**
+     * Wrap an atomic write (writeFile + rename) with retry logic.
+     * Retries only on transient FS errors; cleans up stale .tmp on final failure.
+     */
+    async retryAtomicWrite(tmpPath, fn) {
+        const logger = (0, logger_1.getLogger)();
+        try {
+            await (0, retry_1.withRetry)(fn, {
+                attempts: 3,
+                delayMs: 100,
+                backoff: 'exponential',
+                maxDelayMs: 2000,
+                operationName: `atomic write ${path.basename(tmpPath)}`,
+                retryOn: (error) => {
+                    const code = error?.code;
+                    return !!code && FileProcessStore.RETRYABLE_FS_ERRORS.has(code);
+                },
+                onAttempt: (attempt, maxAttempts, lastError) => {
+                    if (attempt > 1) {
+                        const code = lastError?.code ?? 'unknown';
+                        logger.warn('FileProcessStore', `Retrying atomic write (attempt ${attempt}/${maxAttempts}) after ${code}: ${path.basename(tmpPath)}`);
+                    }
+                },
+            });
+        }
+        catch (outerError) {
+            // Best-effort cleanup of stale .tmp file
+            try {
+                await fs.unlink(tmpPath);
+            }
+            catch { /* ignore */ }
+            throw outerError;
+        }
+    }
+    sanitizeId(id) {
+        return id.replace(/[^a-zA-Z0-9\-_]/g, '_');
+    }
+    async readIndex(workspaceId) {
+        try {
+            const data = await fs.readFile(this.indexPathFor(workspaceId), 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return [];
+        }
+    }
+    async writeIndex(workspaceId, entries) {
+        await ensureDataDir(this.workspaceDirFor(workspaceId));
+        const indexPath = this.indexPathFor(workspaceId);
+        const tmpPath = indexPath + '.tmp';
+        await this.retryAtomicWrite(tmpPath, async () => {
+            await fs.writeFile(tmpPath, JSON.stringify(entries, null, 2), 'utf-8');
+            await fs.rename(tmpPath, indexPath);
+        });
+    }
+    async readProcessFile(workspaceId, id) {
+        try {
+            const data = await fs.readFile(this.getProcessFilePath(workspaceId, id), 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async writeProcessFile(workspaceId, id, entry) {
+        const filePath = this.getProcessFilePath(workspaceId, id);
+        const tmpPath = filePath + '.tmp';
+        await this.retryAtomicWrite(tmpPath, async () => {
+            await fs.writeFile(tmpPath, JSON.stringify(entry, null, 2), 'utf-8');
+            await fs.rename(tmpPath, filePath);
+        });
+    }
+    async moveProcessToPruned(workspaceId, entry) {
+        const src = this.getProcessFilePath(workspaceId, entry.id);
+        const destDir = this.prunedBucketFor(workspaceId, entry.startTime);
+        await ensureDataDir(destDir);
+        const dest = this.getPrunedProcessFilePath(workspaceId, entry.id, entry.startTime);
+        try {
+            await fs.rename(src, dest);
+        }
+        catch {
+            // Cross-device fallback: copy then delete
+            const data = await fs.readFile(src, 'utf-8').catch(() => null);
+            if (data) {
+                await fs.writeFile(dest, data, 'utf-8');
+                await fs.unlink(src).catch(() => { });
+            }
+        }
+    }
+    async deleteProcessFile(workspaceId, id) {
+        try {
+            await fs.unlink(this.getProcessFilePath(workspaceId, id));
+        }
+        catch {
+            // Ignore missing file
+        }
+    }
+    async listWorkspaceDirs() {
+        try {
+            const entries = await fs.readdir(this.processesDir, { withFileTypes: true });
+            return entries
+                .filter(e => e.isDirectory())
+                .map(e => e.name);
+        }
+        catch {
+            return [];
+        }
+    }
+    async aggregateAllIndices() {
+        const workspaceDirs = await this.listWorkspaceDirs();
+        const all = [];
+        for (const wsId of workspaceDirs) {
+            const entries = await this.readIndex(wsId);
+            all.push(...entries);
+        }
+        return all;
+    }
+    /**
+     * Scan per-workspace index.json files to find the workspaceId that owns the given process id.
+     * Returns undefined if not found in any workspace.
+     */
+    async findWorkspaceIdForProcess(id) {
+        const workspaceDirs = await this.listWorkspaceDirs();
+        for (const wsId of workspaceDirs) {
+            const entries = await this.readIndex(wsId);
+            if (entries.some(e => e.id === id)) {
+                return wsId;
+            }
+        }
+        return undefined;
+    }
+    toIndexEntry(entry) {
+        return {
+            id: entry.process.id,
+            workspaceId: entry.workspaceId,
+            status: entry.process.status,
+            type: entry.process.type || 'clarification',
+            startTime: entry.process.startTime,
+            endTime: entry.process.endTime,
+            promptPreview: entry.process.promptPreview,
+            error: entry.process.error,
+            parentProcessId: entry.process.parentProcessId,
+            title: entry.process.title,
+            duration: entry.process.endTime && entry.process.startTime
+                ? new Date(entry.process.endTime).getTime() - new Date(entry.process.startTime).getTime()
+                : undefined,
+        };
+    }
+    async pruneWorkspaceIfNeeded(workspaceId, entries) {
+        if (entries.length <= this.maxProcesses) {
+            return entries;
+        }
+        // Separate non-terminal (running/queued) from terminal processes
+        const nonTerminal = [];
+        const terminal = [];
+        for (const entry of entries) {
+            if (entry.status === 'running' || entry.status === 'queued') {
+                nonTerminal.push(entry);
+            }
+            else {
+                terminal.push(entry);
+            }
+        }
+        // Sort terminal by startTime ascending (oldest first)
+        terminal.sort((a, b) => new Date(a.startTime).getTime() - new Date(b.startTime).getTime());
+        // Remove oldest terminal entries until within limit
+        const toKeep = this.maxProcesses - nonTerminal.length;
+        const keptTerminal = toKeep > 0 ? terminal.slice(terminal.length - toKeep) : [];
+        const prunedEntries = terminal.slice(0, terminal.length - keptTerminal.length);
+        if (prunedEntries.length > 0) {
+            // Notify about pruned entries (load full data for onPrune callback)
+            if (this.onPrune) {
+                const fullEntries = [];
+                for (const ie of prunedEntries) {
+                    const entry = await this.readProcessFile(workspaceId, ie.id);
+                    if (entry) {
+                        fullEntries.push(entry);
+                    }
+                }
+                if (fullEntries.length > 0) {
+                    this.onPrune(fullEntries);
+                }
+            }
+            // Group pruned entries by YYYY-MM bucket and write each bucket index
+            const byBucket = new Map();
+            for (const e of prunedEntries) {
+                const bucket = new Date(e.startTime).toISOString().slice(0, 7);
+                if (!byBucket.has(bucket)) {
+                    byBucket.set(bucket, []);
+                }
+                byBucket.get(bucket).push(e);
+            }
+            for (const [, bucketEntries] of byBucket) {
+                const existing = await this.readPrunedBucketIndex(workspaceId, bucketEntries[0].startTime);
+                await this.writePrunedBucketIndex(workspaceId, bucketEntries[0].startTime, [...existing, ...bucketEntries]);
+            }
+            // Move pruned process files into their bucket directories
+            await Promise.all(prunedEntries.map(e => this.moveProcessToPruned(workspaceId, e)));
+        }
+        return [...nonTerminal, ...keptTerminal];
+    }
+    onProcessOutput(id, callback) {
+        let emitter = this.emitters.get(id);
+        if (!emitter) {
+            emitter = new events_1.EventEmitter();
+            this.emitters.set(id, emitter);
+        }
+        const listener = (event) => callback(event);
+        emitter.on('output', listener);
+        return () => {
+            emitter.removeListener('output', listener);
+        };
+    }
+    emitProcessOutput(id, content) {
+        let emitter = this.emitters.get(id);
+        if (!emitter) {
+            emitter = new events_1.EventEmitter();
+            this.emitters.set(id, emitter);
+        }
+        const event = { type: 'chunk', content };
+        emitter.emit('output', event);
+    }
+    emitProcessComplete(id, status, duration) {
+        const emitter = this.emitters.get(id);
+        if (!emitter) {
+            return;
+        }
+        const event = { type: 'complete', status, duration };
+        emitter.emit('output', event);
+        // Clean up emitter after notifying all listeners
+        this.emitters.delete(id);
+    }
+    emitProcessEvent(id, event) {
+        let emitter = this.emitters.get(id);
+        if (!emitter) {
+            emitter = new events_1.EventEmitter();
+            this.emitters.set(id, emitter);
+        }
+        emitter.emit('output', event);
+    }
+    registerFlushHandler(id, handler) {
+        this.flushHandlers.set(id, handler);
+    }
+    unregisterFlushHandler(id) {
+        this.flushHandlers.delete(id);
+    }
+    async requestFlush(id) {
+        const handler = this.flushHandlers.get(id);
+        if (handler) {
+            await handler();
+        }
+    }
+    async readWorkspaces() {
+        try {
+            const data = await fs.readFile(this.workspacesPath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return [];
+        }
+    }
+    async writeWorkspaces(workspaces) {
+        const tmpPath = this.workspacesPath + '.tmp';
+        await this.retryAtomicWrite(tmpPath, async () => {
+            await fs.writeFile(tmpPath, JSON.stringify(workspaces, null, 2), 'utf-8');
+            await fs.rename(tmpPath, this.workspacesPath);
+        });
+    }
+    async readWikis() {
+        try {
+            const data = await fs.readFile(this.wikisPath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return [];
+        }
+    }
+    async writeWikis(wikis) {
+        const tmpPath = this.wikisPath + '.tmp';
+        await this.retryAtomicWrite(tmpPath, async () => {
+            await fs.writeFile(tmpPath, JSON.stringify(wikis, null, 2), 'utf-8');
+            await fs.rename(tmpPath, this.wikisPath);
+        });
+    }
+    enqueueWrite(fn) {
+        const result = this.writeQueue.then(fn);
+        this.writeQueue = result.then(() => { }, () => { });
+        return result;
+    }
+}
+exports.FileProcessStore = FileProcessStore;
+// --- Internal helpers: per-workspace index + process files ---
+/** Transient FS error codes worth retrying */
+FileProcessStore.RETRYABLE_FS_ERRORS = new Set(['EACCES', 'EBUSY', 'EPERM', 'ENOLCK', 'EIO']);
+//# sourceMappingURL=file-process-store.js.map