@mariozechner/pi-coding-agent 0.52.12 → 0.53.1

package/dist/core/settings-manager.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
+import lockfile from "proper-lockfile";
 import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
 function deepMergeSettings(base, overrides) {
@@ -26,54 +27,116 @@ function deepMergeSettings(base, overrides) {
     }
     return result;
 }
-export class SettingsManager {
-    settingsPath;
+export class FileSettingsStorage {
+    globalSettingsPath;
     projectSettingsPath;
+    constructor(cwd = process.cwd(), agentDir = getAgentDir()) {
+        this.globalSettingsPath = join(agentDir, "settings.json");
+        this.projectSettingsPath = join(cwd, CONFIG_DIR_NAME, "settings.json");
+    }
+    withLock(scope, fn) {
+        const path = scope === "global" ? this.globalSettingsPath : this.projectSettingsPath;
+        const dir = dirname(path);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        let release;
+        try {
+            release = lockfile.lockSync(path, { realpath: false });
+            const current = existsSync(path) ? readFileSync(path, "utf-8") : undefined;
+            const next = fn(current);
+            if (next !== undefined) {
+                writeFileSync(path, next, "utf-8");
+            }
+        }
+        finally {
+            if (release) {
+                release();
+            }
+        }
+    }
+}
+export class InMemorySettingsStorage {
+    global;
+    project;
+    withLock(scope, fn) {
+        const current = scope === "global" ? this.global : this.project;
+        const next = fn(current);
+        if (next !== undefined) {
+            if (scope === "global") {
+                this.global = next;
+            }
+            else {
+                this.project = next;
+            }
+        }
+    }
+}
+export class SettingsManager {
+    storage;
     globalSettings;
-    inMemoryProjectSettings; // For in-memory mode
+    projectSettings;
     settings;
-    persist;
-    modifiedFields = new Set(); // Track fields modified during session
-    modifiedNestedFields = new Map(); // Track nested field modifications
-    globalSettingsLoadError = null; // Track if settings file had parse errors
-    constructor(settingsPath, projectSettingsPath, initialSettings, persist, loadError = null) {
-        this.settingsPath = settingsPath;
-        this.projectSettingsPath = projectSettingsPath;
-        this.persist = persist;
-        this.globalSettings = initialSettings;
-        this.inMemoryProjectSettings = {};
-        this.globalSettingsLoadError = loadError;
-        const projectSettings = this.loadProjectSettings();
-        this.settings = deepMergeSettings(this.globalSettings, projectSettings);
+    modifiedFields = new Set(); // Track global fields modified during session
+    modifiedNestedFields = new Map(); // Track global nested field modifications
+    modifiedProjectFields = new Set(); // Track project fields modified during session
+    modifiedProjectNestedFields = new Map(); // Track project nested field modifications
+    globalSettingsLoadError = null; // Track if global settings file had parse errors
+    projectSettingsLoadError = null; // Track if project settings file had parse errors
+    writeQueue = Promise.resolve();
+    errors;
+    constructor(storage, initialGlobal, initialProject, globalLoadError = null, projectLoadError = null, initialErrors = []) {
+        this.storage = storage;
+        this.globalSettings = initialGlobal;
+        this.projectSettings = initialProject;
+        this.globalSettingsLoadError = globalLoadError;
+        this.projectSettingsLoadError = projectLoadError;
+        this.errors = [...initialErrors];
+        this.settings = deepMergeSettings(this.globalSettings, this.projectSettings);
     }
     /** Create a SettingsManager that loads from files */
     static create(cwd = process.cwd(), agentDir = getAgentDir()) {
-        const settingsPath = join(agentDir, "settings.json");
-        const projectSettingsPath = join(cwd, CONFIG_DIR_NAME, "settings.json");
-        let globalSettings = {};
-        let loadError = null;
-        try {
-            globalSettings = SettingsManager.loadFromFile(settingsPath);
+        const storage = new FileSettingsStorage(cwd, agentDir);
+        return SettingsManager.fromStorage(storage);
+    }
+    /** Create a SettingsManager from an arbitrary storage backend */
+    static fromStorage(storage) {
+        const globalLoad = SettingsManager.tryLoadFromStorage(storage, "global");
+        const projectLoad = SettingsManager.tryLoadFromStorage(storage, "project");
+        const initialErrors = [];
+        if (globalLoad.error) {
+            initialErrors.push({ scope: "global", error: globalLoad.error });
         }
-        catch (error) {
-            loadError = error;
-            console.error(`Warning: Invalid JSON in ${settingsPath}: ${error}`);
-            console.error(`Fix the syntax error to enable settings persistence.`);
+        if (projectLoad.error) {
+            initialErrors.push({ scope: "project", error: projectLoad.error });
         }
-        return new SettingsManager(settingsPath, projectSettingsPath, globalSettings, true, loadError);
+        return new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors);
     }
     /** Create an in-memory SettingsManager (no file I/O) */
     static inMemory(settings = {}) {
-        return new SettingsManager(null, null, settings, false);
-    }
-    static loadFromFile(path) {
-        if (!existsSync(path)) {
+        const storage = new InMemorySettingsStorage();
+        return new SettingsManager(storage, settings, {});
+    }
+    static loadFromStorage(storage, scope) {
+        let content;
+        storage.withLock(scope, (current) => {
+            content = current;
+            return undefined;
+        });
+        if (!content) {
             return {};
         }
-        const content = readFileSync(path, "utf-8");
         const settings = JSON.parse(content);
         return SettingsManager.migrateSettings(settings);
     }
+    static tryLoadFromStorage(storage, scope) {
+        try {
+            return { settings: SettingsManager.loadFromStorage(storage, scope), error: null };
+        }
+        catch (error) {
+            return { settings: {}, error: error };
+        }
+    }
     /** Migrate old settings format to new format */
     static migrateSettings(settings) {
         // Migrate queueMode -> steeringMode
@@ -104,54 +167,42 @@ export class SettingsManager {
         }
         return settings;
     }
-    loadProjectSettings() {
-        // In-memory mode: return stored in-memory project settings
-        if (!this.persist) {
-            return structuredClone(this.inMemoryProjectSettings);
-        }
-        if (!this.projectSettingsPath || !existsSync(this.projectSettingsPath)) {
-            return {};
-        }
-        try {
-            const content = readFileSync(this.projectSettingsPath, "utf-8");
-            const settings = JSON.parse(content);
-            return SettingsManager.migrateSettings(settings);
-        }
-        catch (error) {
-            console.error(`Warning: Could not read project settings file: ${error}`);
-            return {};
-        }
-    }
     getGlobalSettings() {
         return structuredClone(this.globalSettings);
     }
     getProjectSettings() {
-        return this.loadProjectSettings();
+        return structuredClone(this.projectSettings);
     }
     reload() {
-        let nextGlobalSettings = null;
-        if (this.persist && this.settingsPath) {
-            try {
-                nextGlobalSettings = SettingsManager.loadFromFile(this.settingsPath);
-                this.globalSettingsLoadError = null;
-            }
-            catch (error) {
-                this.globalSettingsLoadError = error;
-            }
+        const globalLoad = SettingsManager.tryLoadFromStorage(this.storage, "global");
+        if (!globalLoad.error) {
+            this.globalSettings = globalLoad.settings;
+            this.globalSettingsLoadError = null;
         }
-        if (nextGlobalSettings) {
-            this.globalSettings = nextGlobalSettings;
+        else {
+            this.globalSettingsLoadError = globalLoad.error;
+            this.recordError("global", globalLoad.error);
         }
         this.modifiedFields.clear();
         this.modifiedNestedFields.clear();
-        const projectSettings = this.loadProjectSettings();
-        this.settings = deepMergeSettings(this.globalSettings, projectSettings);
+        this.modifiedProjectFields.clear();
+        this.modifiedProjectNestedFields.clear();
+        const projectLoad = SettingsManager.tryLoadFromStorage(this.storage, "project");
+        if (!projectLoad.error) {
+            this.projectSettings = projectLoad.settings;
+            this.projectSettingsLoadError = null;
+        }
+        else {
+            this.projectSettingsLoadError = projectLoad.error;
+            this.recordError("project", projectLoad.error);
+        }
+        this.settings = deepMergeSettings(this.globalSettings, this.projectSettings);
     }
     /** Apply additional overrides on top of current settings */
     applyOverrides(overrides) {
         this.settings = deepMergeSettings(this.settings, overrides);
     }
-    /** Mark a field as modified during this session */
+    /** Mark a global field as modified during this session */
     markModified(field, nestedKey) {
         this.modifiedFields.add(field);
         if (nestedKey) {
@@ -161,74 +212,103 @@ export class SettingsManager {
             this.modifiedNestedFields.get(field).add(nestedKey);
         }
     }
-    save() {
-        if (this.persist && this.settingsPath) {
-            // Don't overwrite if the file had parse errors on initial load
-            if (this.globalSettingsLoadError) {
-                // Re-merge to update active settings even though we can't persist
-                const projectSettings = this.loadProjectSettings();
-                this.settings = deepMergeSettings(this.globalSettings, projectSettings);
-                return;
-            }
-            try {
-                const dir = dirname(this.settingsPath);
-                if (!existsSync(dir)) {
-                    mkdirSync(dir, { recursive: true });
-                }
-                // Re-read current file to get latest external changes
-                const currentFileSettings = SettingsManager.loadFromFile(this.settingsPath);
-                // Start with file settings as base - preserves external edits
-                const mergedSettings = { ...currentFileSettings };
-                // Only override with in-memory values for fields that were explicitly modified during this session
-                for (const field of this.modifiedFields) {
-                    const value = this.globalSettings[field];
-                    // Handle nested objects specially - merge at nested level to preserve unmodified nested keys
-                    if (this.modifiedNestedFields.has(field) && typeof value === "object" && value !== null) {
-                        const nestedModified = this.modifiedNestedFields.get(field);
-                        const baseNested = currentFileSettings[field] ?? {};
-                        const inMemoryNested = value;
-                        const mergedNested = { ...baseNested };
-                        for (const nestedKey of nestedModified) {
-                            mergedNested[nestedKey] = inMemoryNested[nestedKey];
-                        }
-                        mergedSettings[field] = mergedNested;
-                    }
-                    else {
-                        // For top-level primitives and arrays, use the modified value directly
-                        mergedSettings[field] = value;
-                    }
-                }
-                this.globalSettings = mergedSettings;
-                writeFileSync(this.settingsPath, JSON.stringify(this.globalSettings, null, 2), "utf-8");
-            }
-            catch (error) {
-                // File may have been externally modified with invalid JSON - don't overwrite
-                console.error(`Warning: Could not save settings file: ${error}`);
+    /** Mark a project field as modified during this session */
+    markProjectModified(field, nestedKey) {
+        this.modifiedProjectFields.add(field);
+        if (nestedKey) {
+            if (!this.modifiedProjectNestedFields.has(field)) {
+                this.modifiedProjectNestedFields.set(field, new Set());
             }
+            this.modifiedProjectNestedFields.get(field).add(nestedKey);
         }
-        // Always re-merge to update active settings (needed for both file and inMemory modes)
-        const projectSettings = this.loadProjectSettings();
-        this.settings = deepMergeSettings(this.globalSettings, projectSettings);
     }
-    saveProjectSettings(settings) {
-        // In-memory mode: store in memory
-        if (!this.persist) {
-            this.inMemoryProjectSettings = structuredClone(settings);
+    recordError(scope, error) {
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        this.errors.push({ scope, error: normalizedError });
+    }
+    clearModifiedScope(scope) {
+        if (scope === "global") {
+            this.modifiedFields.clear();
+            this.modifiedNestedFields.clear();
             return;
         }
-        if (!this.projectSettingsPath) {
-            return;
+        this.modifiedProjectFields.clear();
+        this.modifiedProjectNestedFields.clear();
+    }
+    enqueueWrite(scope, task) {
+        this.writeQueue = this.writeQueue
+            .then(() => {
+            task();
+            this.clearModifiedScope(scope);
+        })
+            .catch((error) => {
+            this.recordError(scope, error);
+        });
+    }
+    cloneModifiedNestedFields(source) {
+        const snapshot = new Map();
+        for (const [key, value] of source.entries()) {
+            snapshot.set(key, new Set(value));
         }
-        try {
-            const dir = dirname(this.projectSettingsPath);
-            if (!existsSync(dir)) {
-                mkdirSync(dir, { recursive: true });
+        return snapshot;
+    }
+    persistScopedSettings(scope, snapshotSettings, modifiedFields, modifiedNestedFields) {
+        this.storage.withLock(scope, (current) => {
+            const currentFileSettings = current
+                ? SettingsManager.migrateSettings(JSON.parse(current))
+                : {};
+            const mergedSettings = { ...currentFileSettings };
+            for (const field of modifiedFields) {
+                const value = snapshotSettings[field];
+                if (modifiedNestedFields.has(field) && typeof value === "object" && value !== null) {
+                    const nestedModified = modifiedNestedFields.get(field);
+                    const baseNested = currentFileSettings[field] ?? {};
+                    const inMemoryNested = value;
+                    const mergedNested = { ...baseNested };
+                    for (const nestedKey of nestedModified) {
+                        mergedNested[nestedKey] = inMemoryNested[nestedKey];
+                    }
+                    mergedSettings[field] = mergedNested;
+                }
+                else {
+                    mergedSettings[field] = value;
+                }
             }
-            writeFileSync(this.projectSettingsPath, JSON.stringify(settings, null, 2), "utf-8");
+            return JSON.stringify(mergedSettings, null, 2);
+        });
+    }
+    save() {
+        this.settings = deepMergeSettings(this.globalSettings, this.projectSettings);
+        if (this.globalSettingsLoadError) {
+            return;
         }
-        catch (error) {
-            console.error(`Warning: Could not save project settings file: ${error}`);
+        const snapshotGlobalSettings = structuredClone(this.globalSettings);
+        const modifiedFields = new Set(this.modifiedFields);
+        const modifiedNestedFields = this.cloneModifiedNestedFields(this.modifiedNestedFields);
+        this.enqueueWrite("global", () => {
+            this.persistScopedSettings("global", snapshotGlobalSettings, modifiedFields, modifiedNestedFields);
+        });
+    }
+    saveProjectSettings(settings) {
+        this.projectSettings = structuredClone(settings);
+        this.settings = deepMergeSettings(this.globalSettings, this.projectSettings);
+        if (this.projectSettingsLoadError) {
+            return;
         }
+        const snapshotProjectSettings = structuredClone(this.projectSettings);
+        const modifiedFields = new Set(this.modifiedProjectFields);
+        const modifiedNestedFields = this.cloneModifiedNestedFields(this.modifiedProjectNestedFields);
+        this.enqueueWrite("project", () => {
+            this.persistScopedSettings("project", snapshotProjectSettings, modifiedFields, modifiedNestedFields);
+        });
+    }
+    async flush() {
+        await this.writeQueue;
+    }
+    drainErrors() {
+        const drained = [...this.errors];
+        this.errors = [];
+        return drained;
     }
     getLastChangelogVersion() {
         return this.settings.lastChangelogVersion;
@@ -398,10 +478,10 @@ export class SettingsManager {
         this.save();
     }
     setProjectPackages(packages) {
-        const projectSettings = this.loadProjectSettings();
+        const projectSettings = structuredClone(this.projectSettings);
         projectSettings.packages = packages;
+        this.markProjectModified("packages");
         this.saveProjectSettings(projectSettings);
-        this.settings = deepMergeSettings(this.globalSettings, projectSettings);
     }
     getExtensionPaths() {
         return [...(this.settings.extensions ?? [])];
@@ -412,10 +492,10 @@ export class SettingsManager {
         this.save();
     }
     setProjectExtensionPaths(paths) {
-        const projectSettings = this.loadProjectSettings();
+        const projectSettings = structuredClone(this.projectSettings);
         projectSettings.extensions = paths;
+        this.markProjectModified("extensions");
         this.saveProjectSettings(projectSettings);
-        this.settings = deepMergeSettings(this.globalSettings, projectSettings);
     }
     getSkillPaths() {
         return [...(this.settings.skills ?? [])];
@@ -426,10 +506,10 @@ export class SettingsManager {
         this.save();
     }
     setProjectSkillPaths(paths) {
-        const projectSettings = this.loadProjectSettings();
+        const projectSettings = structuredClone(this.projectSettings);
         projectSettings.skills = paths;
+        this.markProjectModified("skills");
         this.saveProjectSettings(projectSettings);
-        this.settings = deepMergeSettings(this.globalSettings, projectSettings);
     }
     getPromptTemplatePaths() {
         return [...(this.settings.prompts ?? [])];
@@ -440,10 +520,10 @@ export class SettingsManager {
         this.save();
     }
     setProjectPromptTemplatePaths(paths) {
-        const projectSettings = this.loadProjectSettings();
+        const projectSettings = structuredClone(this.projectSettings);
         projectSettings.prompts = paths;
+        this.markProjectModified("prompts");
         this.saveProjectSettings(projectSettings);
-        this.settings = deepMergeSettings(this.globalSettings, projectSettings);
     }
     getThemePaths() {
         return [...(this.settings.themes ?? [])];
@@ -454,10 +534,10 @@ export class SettingsManager {
         this.save();
     }
     setProjectThemePaths(paths) {
-        const projectSettings = this.loadProjectSettings();
+        const projectSettings = structuredClone(this.projectSettings);
         projectSettings.themes = paths;
+        this.markProjectModified("themes");
         this.saveProjectSettings(projectSettings);
-        this.settings = deepMergeSettings(this.globalSettings, projectSettings);
     }
     getEnableSkillCommands() {
         return this.settings.enableSkillCommands ?? true;