projax 3.3.40 → 3.3.51

package/dist/electron/core/git-utils.js

@@ -0,0 +1,87 @@
+"use strict";
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBranchesForProjects = exports.getCurrentBranch = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Get the current git branch for a project
+ * @param projectPath The path to the project directory
+ * @returns The current branch name, or null if not a git repo or on error
+ */
+function getCurrentBranch(projectPath) {
+    try {
+        // Check if .git directory exists
+        const gitDir = path.join(projectPath, '.git');
+        if (!fs.existsSync(gitDir) && !fs.existsSync(path.join(projectPath, '.git', 'HEAD'))) {
+            // Check if it's a worktree or submodule
+            const gitConfig = path.join(projectPath, '.git');
+            if (!fs.existsSync(gitConfig)) {
+                return null;
+            }
+        }
+        // Try to get the current branch
+        const branch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+            cwd: projectPath,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        // Handle detached HEAD state (returns "HEAD")
+        if (branch === 'HEAD') {
+            // Try to get the commit hash instead
+            try {
+                const commit = (0, child_process_1.execSync)('git rev-parse --short HEAD', {
+                    cwd: projectPath,
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                }).trim();
+                return `detached@${commit}`;
+            }
+            catch {
+                return 'detached';
+            }
+        }
+        return branch || null;
+    }
+    catch (error) {
+        // Not a git repo, or git command failed
+        return null;
+    }
+}
+exports.getCurrentBranch = getCurrentBranch;
+/**
+ * Get git branches for multiple projects
+ * @param projectPaths Array of project paths
+ * @returns Map of project path to branch name (or null)
+ */
+function getBranchesForProjects(projectPaths) {
+    const branches = new Map();
+    for (const projectPath of projectPaths) {
+        branches.set(projectPath, getCurrentBranch(projectPath));
+    }
+    return branches;
+}
+exports.getBranchesForProjects = getBranchesForProjects;

package/dist/electron/core/index.d.ts

@@ -2,6 +2,9 @@ export * from './database';
 export * from './detector';
 export * from './scanner';
 export * from './settings';
+export * from './git-utils';
+export * from './workspace-utils';
+export * from './backup-utils';
 export { getDatabaseManager } from './database';
 import { Project, Test } from './database';
 export declare function getAllProjects(): Project[];

package/dist/electron/core/index.js

@@ -14,15 +14,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDatabaseManager = void 0;
-exports.getAllProjects = getAllProjects;
-exports.addProject = addProject;
-exports.removeProject = removeProject;
-exports.getTestsByProject = getTestsByProject;
+exports.getTestsByProject = exports.removeProject = exports.addProject = exports.getAllProjects = exports.getDatabaseManager = void 0;
 __exportStar(require("./database"), exports);
 __exportStar(require("./detector"), exports);
 __exportStar(require("./scanner"), exports);
 __exportStar(require("./settings"), exports);
+__exportStar(require("./git-utils"), exports);
+__exportStar(require("./workspace-utils"), exports);
+__exportStar(require("./backup-utils"), exports);
 var database_1 = require("./database");
 Object.defineProperty(exports, "getDatabaseManager", { enumerable: true, get: function () { return database_1.getDatabaseManager; } });
 // Convenience functions for common operations
@@ -30,12 +29,16 @@ const database_2 = require("./database");
 function getAllProjects() {
     return (0, database_2.getDatabaseManager)().getAllProjects();
 }
+exports.getAllProjects = getAllProjects;
 function addProject(name, projectPath) {
     return (0, database_2.getDatabaseManager)().addProject(name, projectPath);
 }
+exports.addProject = addProject;
 function removeProject(id) {
     (0, database_2.getDatabaseManager)().removeProject(id);
 }
+exports.removeProject = removeProject;
 function getTestsByProject(projectId) {
     return (0, database_2.getDatabaseManager)().getTestsByProject(projectId);
 }
+exports.getTestsByProject = getTestsByProject;

package/dist/electron/core/scanner.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scanProject = scanProject;
-exports.scanAllProjects = scanAllProjects;
+exports.scanAllProjects = exports.scanProject = void 0;
 const database_1 = require("./database");
 function scanProject(projectId) {
     return (0, database_1.getDatabaseManager)().scanProject(projectId);
 }
+exports.scanProject = scanProject;
 function scanAllProjects() {
     return (0, database_1.getDatabaseManager)().scanAllProjects();
 }
+exports.scanAllProjects = scanAllProjects;

package/dist/electron/core/settings.d.ts

@@ -8,9 +8,62 @@ export interface BrowserSettings {
     type: BrowserType;
     customPath?: string;
 }
+export interface DisplaySettings {
+    projectTiles: {
+        showName: boolean;
+        showDescription: boolean;
+        showTags: boolean;
+        showRunningIndicator: boolean;
+        showPorts: boolean;
+        showGitBranch: boolean;
+    };
+    projectDetails: {
+        showStats: boolean;
+        showTestResults: boolean;
+        showTags: boolean;
+        showUrls: boolean;
+        showScripts: boolean;
+        showJenkins: boolean;
+    };
+    workspaceTiles: {
+        showName: boolean;
+        showDescription: boolean;
+        showPath: boolean;
+        showTags: boolean;
+        showProjectCount: boolean;
+    };
+    workspaceDetails: {
+        showProjectList: boolean;
+        showDescription: boolean;
+        showPath: boolean;
+    };
+}
+export interface AppearanceSettings {
+    theme?: string;
+    uiDensity?: 'compact' | 'normal' | 'comfortable';
+    fontSize?: number;
+    animations?: boolean;
+    defaultView?: 'projects' | 'workspaces';
+}
+export interface BehaviorSettings {
+    autoScanOnAdd?: boolean;
+    refreshInterval?: number;
+    autoOpenTerminal?: boolean;
+    notifications?: boolean;
+    defaultScriptSortOrder?: 'default' | 'alphabetical' | 'last-used';
+}
+export interface AdvancedSettings {
+    apiPortOverride?: number | null;
+    databaseLocation?: string;
+    debugMode?: boolean;
+}
 export interface AppSettings {
     editor: EditorSettings;
     browser: BrowserSettings;
+    display?: DisplaySettings;
+    appearance?: AppearanceSettings;
+    behavior?: BehaviorSettings;
+    advanced?: AdvancedSettings;
 }
 /**
  * Get a setting value by key
@@ -40,6 +93,38 @@ export declare function getBrowserSettings(): BrowserSettings;
  * Set browser settings
  */
 export declare function setBrowserSettings(settings: BrowserSettings): void;
+/**
+ * Get display settings
+ */
+export declare function getDisplaySettings(): DisplaySettings;
+/**
+ * Set display settings
+ */
+export declare function setDisplaySettings(settings: DisplaySettings): void;
+/**
+ * Get appearance settings
+ */
+export declare function getAppearanceSettings(): AppearanceSettings;
+/**
+ * Set appearance settings
+ */
+export declare function setAppearanceSettings(settings: AppearanceSettings): void;
+/**
+ * Get behavior settings
+ */
+export declare function getBehaviorSettings(): BehaviorSettings;
+/**
+ * Set behavior settings
+ */
+export declare function setBehaviorSettings(settings: BehaviorSettings): void;
+/**
+ * Get advanced settings
+ */
+export declare function getAdvancedSettings(): AdvancedSettings;
+/**
+ * Set advanced settings
+ */
+export declare function setAdvancedSettings(settings: AdvancedSettings): void;
 /**
  * Get all app settings
  */

package/dist/electron/core/settings.js

@@ -1,15 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSetting = getSetting;
-exports.setSetting = setSetting;
-exports.getAllSettings = getAllSettings;
-exports.getEditorSettings = getEditorSettings;
-exports.setEditorSettings = setEditorSettings;
-exports.getBrowserSettings = getBrowserSettings;
-exports.setBrowserSettings = setBrowserSettings;
-exports.getAppSettings = getAppSettings;
-exports.setAppSettings = setAppSettings;
+exports.setAppSettings = exports.getAppSettings = exports.setAdvancedSettings = exports.getAdvancedSettings = exports.setBehaviorSettings = exports.getBehaviorSettings = exports.setAppearanceSettings = exports.getAppearanceSettings = exports.setDisplaySettings = exports.getDisplaySettings = exports.setBrowserSettings = exports.getBrowserSettings = exports.setEditorSettings = exports.getEditorSettings = exports.getAllSettings = exports.setSetting = exports.getSetting = void 0;
 const database_1 = require("./database");
+const DEFAULT_DISPLAY_SETTINGS = {
+    projectTiles: {
+        showName: true,
+        showDescription: true,
+        showTags: true,
+        showRunningIndicator: true,
+        showPorts: true,
+        showGitBranch: true,
+    },
+    projectDetails: {
+        showStats: true,
+        showTestResults: true,
+        showTags: true,
+        showUrls: true,
+        showScripts: true,
+        showJenkins: false,
+    },
+    workspaceTiles: {
+        showName: true,
+        showDescription: true,
+        showPath: true,
+        showTags: true,
+        showProjectCount: true,
+    },
+    workspaceDetails: {
+        showProjectList: true,
+        showDescription: true,
+        showPath: true,
+    },
+};
 const DEFAULT_SETTINGS = {
     editor: {
         type: 'vscode',
@@ -17,6 +39,24 @@ const DEFAULT_SETTINGS = {
     browser: {
         type: 'chrome',
     },
+    display: DEFAULT_DISPLAY_SETTINGS,
+    appearance: {
+        uiDensity: 'normal',
+        fontSize: 13,
+        animations: true,
+        defaultView: 'projects',
+    },
+    behavior: {
+        autoScanOnAdd: true,
+        refreshInterval: 5000,
+        autoOpenTerminal: false,
+        notifications: true,
+        defaultScriptSortOrder: 'default',
+    },
+    advanced: {
+        apiPortOverride: null,
+        debugMode: false,
+    },
 };
 /**
  * Get a setting value by key
@@ -24,18 +64,21 @@ const DEFAULT_SETTINGS = {
 function getSetting(key) {
     return (0, database_1.getDatabaseManager)().getSetting(key);
 }
+exports.getSetting = getSetting;
 /**
  * Set a setting value by key
  */
 function setSetting(key, value) {
     (0, database_1.getDatabaseManager)().setSetting(key, value);
 }
+exports.setSetting = setSetting;
 /**
  * Get all settings as a key-value object
  */
 function getAllSettings() {
     return (0, database_1.getDatabaseManager)().getAllSettings();
 }
+exports.getAllSettings = getAllSettings;
 /**
  * Get editor settings
  */
@@ -48,6 +91,7 @@ function getEditorSettings() {
         customPath,
     };
 }
+exports.getEditorSettings = getEditorSettings;
 /**
  * Set editor settings
  */
@@ -60,6 +104,7 @@ function setEditorSettings(settings) {
     // Note: Removing settings is not yet supported via the API
     // Setting to empty string would achieve similar effect if needed
 }
+exports.setEditorSettings = setEditorSettings;
 /**
  * Get browser settings
  */
@@ -72,6 +117,7 @@ function getBrowserSettings() {
         customPath,
     };
 }
+exports.getBrowserSettings = getBrowserSettings;
 /**
  * Set browser settings
  */
@@ -84,6 +130,243 @@ function setBrowserSettings(settings) {
     // Note: Removing settings is not yet supported via the API
     // Setting to empty string would achieve similar effect if needed
 }
+exports.setBrowserSettings = setBrowserSettings;
+/**
+ * Get display settings
+ */
+function getDisplaySettings() {
+    const db = (0, database_1.getDatabaseManager)();
+    const settings = { ...DEFAULT_DISPLAY_SETTINGS };
+    // Project tiles
+    const ptShowName = db.getSetting('display.projectTiles.showName');
+    if (ptShowName !== null)
+        settings.projectTiles.showName = ptShowName === 'true';
+    const ptShowDesc = db.getSetting('display.projectTiles.showDescription');
+    if (ptShowDesc !== null)
+        settings.projectTiles.showDescription = ptShowDesc === 'true';
+    const ptShowTags = db.getSetting('display.projectTiles.showTags');
+    if (ptShowTags !== null)
+        settings.projectTiles.showTags = ptShowTags === 'true';
+    const ptShowRunning = db.getSetting('display.projectTiles.showRunningIndicator');
+    if (ptShowRunning !== null)
+        settings.projectTiles.showRunningIndicator = ptShowRunning === 'true';
+    const ptShowPorts = db.getSetting('display.projectTiles.showPorts');
+    if (ptShowPorts !== null)
+        settings.projectTiles.showPorts = ptShowPorts === 'true';
+    const ptShowGit = db.getSetting('display.projectTiles.showGitBranch');
+    if (ptShowGit !== null)
+        settings.projectTiles.showGitBranch = ptShowGit === 'true';
+    // Project details
+    const pdShowStats = db.getSetting('display.projectDetails.showStats');
+    if (pdShowStats !== null)
+        settings.projectDetails.showStats = pdShowStats === 'true';
+    const pdShowTests = db.getSetting('display.projectDetails.showTestResults');
+    if (pdShowTests !== null)
+        settings.projectDetails.showTestResults = pdShowTests === 'true';
+    const pdShowTags = db.getSetting('display.projectDetails.showTags');
+    if (pdShowTags !== null)
+        settings.projectDetails.showTags = pdShowTags === 'true';
+    const pdShowUrls = db.getSetting('display.projectDetails.showUrls');
+    if (pdShowUrls !== null)
+        settings.projectDetails.showUrls = pdShowUrls === 'true';
+    const pdShowScripts = db.getSetting('display.projectDetails.showScripts');
+    if (pdShowScripts !== null)
+        settings.projectDetails.showScripts = pdShowScripts === 'true';
+    const pdShowJenkins = db.getSetting('display.projectDetails.showJenkins');
+    if (pdShowJenkins !== null)
+        settings.projectDetails.showJenkins = pdShowJenkins === 'true';
+    // Workspace tiles
+    const wtShowName = db.getSetting('display.workspaceTiles.showName');
+    if (wtShowName !== null)
+        settings.workspaceTiles.showName = wtShowName === 'true';
+    const wtShowDesc = db.getSetting('display.workspaceTiles.showDescription');
+    if (wtShowDesc !== null)
+        settings.workspaceTiles.showDescription = wtShowDesc === 'true';
+    const wtShowPath = db.getSetting('display.workspaceTiles.showPath');
+    if (wtShowPath !== null)
+        settings.workspaceTiles.showPath = wtShowPath === 'true';
+    const wtShowTags = db.getSetting('display.workspaceTiles.showTags');
+    if (wtShowTags !== null)
+        settings.workspaceTiles.showTags = wtShowTags === 'true';
+    const wtShowCount = db.getSetting('display.workspaceTiles.showProjectCount');
+    if (wtShowCount !== null)
+        settings.workspaceTiles.showProjectCount = wtShowCount === 'true';
+    // Workspace details
+    const wdShowList = db.getSetting('display.workspaceDetails.showProjectList');
+    if (wdShowList !== null)
+        settings.workspaceDetails.showProjectList = wdShowList === 'true';
+    const wdShowDesc = db.getSetting('display.workspaceDetails.showDescription');
+    if (wdShowDesc !== null)
+        settings.workspaceDetails.showDescription = wdShowDesc === 'true';
+    const wdShowPath = db.getSetting('display.workspaceDetails.showPath');
+    if (wdShowPath !== null)
+        settings.workspaceDetails.showPath = wdShowPath === 'true';
+    return settings;
+}
+exports.getDisplaySettings = getDisplaySettings;
+/**
+ * Set display settings
+ */
+function setDisplaySettings(settings) {
+    const db = (0, database_1.getDatabaseManager)();
+    // Project tiles
+    db.setSetting('display.projectTiles.showName', String(settings.projectTiles.showName));
+    db.setSetting('display.projectTiles.showDescription', String(settings.projectTiles.showDescription));
+    db.setSetting('display.projectTiles.showTags', String(settings.projectTiles.showTags));
+    db.setSetting('display.projectTiles.showRunningIndicator', String(settings.projectTiles.showRunningIndicator));
+    db.setSetting('display.projectTiles.showPorts', String(settings.projectTiles.showPorts));
+    db.setSetting('display.projectTiles.showGitBranch', String(settings.projectTiles.showGitBranch));
+    // Project details
+    db.setSetting('display.projectDetails.showStats', String(settings.projectDetails.showStats));
+    db.setSetting('display.projectDetails.showTestResults', String(settings.projectDetails.showTestResults));
+    db.setSetting('display.projectDetails.showTags', String(settings.projectDetails.showTags));
+    db.setSetting('display.projectDetails.showUrls', String(settings.projectDetails.showUrls));
+    db.setSetting('display.projectDetails.showScripts', String(settings.projectDetails.showScripts));
+    db.setSetting('display.projectDetails.showJenkins', String(settings.projectDetails.showJenkins));
+    // Workspace tiles
+    db.setSetting('display.workspaceTiles.showName', String(settings.workspaceTiles.showName));
+    db.setSetting('display.workspaceTiles.showDescription', String(settings.workspaceTiles.showDescription));
+    db.setSetting('display.workspaceTiles.showPath', String(settings.workspaceTiles.showPath));
+    db.setSetting('display.workspaceTiles.showTags', String(settings.workspaceTiles.showTags));
+    db.setSetting('display.workspaceTiles.showProjectCount', String(settings.workspaceTiles.showProjectCount));
+    // Workspace details
+    db.setSetting('display.workspaceDetails.showProjectList', String(settings.workspaceDetails.showProjectList));
+    db.setSetting('display.workspaceDetails.showDescription', String(settings.workspaceDetails.showDescription));
+    db.setSetting('display.workspaceDetails.showPath', String(settings.workspaceDetails.showPath));
+}
+exports.setDisplaySettings = setDisplaySettings;
+/**
+ * Get appearance settings
+ */
+function getAppearanceSettings() {
+    const db = (0, database_1.getDatabaseManager)();
+    const settings = { ...DEFAULT_SETTINGS.appearance };
+    const theme = db.getSetting('appearance.theme');
+    if (theme)
+        settings.theme = theme;
+    const uiDensity = db.getSetting('appearance.uiDensity');
+    if (uiDensity && ['compact', 'normal', 'comfortable'].includes(uiDensity)) {
+        settings.uiDensity = uiDensity;
+    }
+    const fontSize = db.getSetting('appearance.fontSize');
+    if (fontSize) {
+        const size = parseInt(fontSize, 10);
+        if (!isNaN(size))
+            settings.fontSize = size;
+    }
+    const animations = db.getSetting('appearance.animations');
+    if (animations !== null)
+        settings.animations = animations === 'true';
+    const defaultView = db.getSetting('appearance.defaultView');
+    if (defaultView && ['projects', 'workspaces'].includes(defaultView)) {
+        settings.defaultView = defaultView;
+    }
+    return settings;
+}
+exports.getAppearanceSettings = getAppearanceSettings;
+/**
+ * Set appearance settings
+ */
+function setAppearanceSettings(settings) {
+    const db = (0, database_1.getDatabaseManager)();
+    if (settings.theme !== undefined)
+        db.setSetting('appearance.theme', settings.theme);
+    if (settings.uiDensity !== undefined)
+        db.setSetting('appearance.uiDensity', settings.uiDensity);
+    if (settings.fontSize !== undefined)
+        db.setSetting('appearance.fontSize', String(settings.fontSize));
+    if (settings.animations !== undefined)
+        db.setSetting('appearance.animations', String(settings.animations));
+    if (settings.defaultView !== undefined)
+        db.setSetting('appearance.defaultView', settings.defaultView);
+}
+exports.setAppearanceSettings = setAppearanceSettings;
+/**
+ * Get behavior settings
+ */
+function getBehaviorSettings() {
+    const db = (0, database_1.getDatabaseManager)();
+    const settings = { ...DEFAULT_SETTINGS.behavior };
+    const autoScan = db.getSetting('behavior.autoScanOnAdd');
+    if (autoScan !== null)
+        settings.autoScanOnAdd = autoScan === 'true';
+    const refreshInterval = db.getSetting('behavior.refreshInterval');
+    if (refreshInterval) {
+        const interval = parseInt(refreshInterval, 10);
+        if (!isNaN(interval))
+            settings.refreshInterval = interval;
+    }
+    const autoOpenTerminal = db.getSetting('behavior.autoOpenTerminal');
+    if (autoOpenTerminal !== null)
+        settings.autoOpenTerminal = autoOpenTerminal === 'true';
+    const notifications = db.getSetting('behavior.notifications');
+    if (notifications !== null)
+        settings.notifications = notifications === 'true';
+    const defaultSort = db.getSetting('behavior.defaultScriptSortOrder');
+    if (defaultSort && ['default', 'alphabetical', 'last-used'].includes(defaultSort)) {
+        settings.defaultScriptSortOrder = defaultSort;
+    }
+    return settings;
+}
+exports.getBehaviorSettings = getBehaviorSettings;
+/**
+ * Set behavior settings
+ */
+function setBehaviorSettings(settings) {
+    const db = (0, database_1.getDatabaseManager)();
+    if (settings.autoScanOnAdd !== undefined)
+        db.setSetting('behavior.autoScanOnAdd', String(settings.autoScanOnAdd));
+    if (settings.refreshInterval !== undefined)
+        db.setSetting('behavior.refreshInterval', String(settings.refreshInterval));
+    if (settings.autoOpenTerminal !== undefined)
+        db.setSetting('behavior.autoOpenTerminal', String(settings.autoOpenTerminal));
+    if (settings.notifications !== undefined)
+        db.setSetting('behavior.notifications', String(settings.notifications));
+    if (settings.defaultScriptSortOrder !== undefined)
+        db.setSetting('behavior.defaultScriptSortOrder', settings.defaultScriptSortOrder);
+}
+exports.setBehaviorSettings = setBehaviorSettings;
+/**
+ * Get advanced settings
+ */
+function getAdvancedSettings() {
+    const db = (0, database_1.getDatabaseManager)();
+    const settings = { ...DEFAULT_SETTINGS.advanced };
+    const apiPort = db.getSetting('advanced.apiPortOverride');
+    if (apiPort !== null) {
+        if (apiPort === '') {
+            settings.apiPortOverride = null;
+        }
+        else {
+            const port = parseInt(apiPort, 10);
+            if (!isNaN(port))
+                settings.apiPortOverride = port;
+        }
+    }
+    const dbLocation = db.getSetting('advanced.databaseLocation');
+    if (dbLocation)
+        settings.databaseLocation = dbLocation;
+    const debugMode = db.getSetting('advanced.debugMode');
+    if (debugMode !== null)
+        settings.debugMode = debugMode === 'true';
+    return settings;
+}
+exports.getAdvancedSettings = getAdvancedSettings;
+/**
+ * Set advanced settings
+ */
+function setAdvancedSettings(settings) {
+    const db = (0, database_1.getDatabaseManager)();
+    if (settings.apiPortOverride !== undefined) {
+        db.setSetting('advanced.apiPortOverride', settings.apiPortOverride === null ? '' : String(settings.apiPortOverride));
+    }
+    if (settings.databaseLocation !== undefined && settings.databaseLocation) {
+        db.setSetting('advanced.databaseLocation', settings.databaseLocation);
+    }
+    if (settings.debugMode !== undefined)
+        db.setSetting('advanced.debugMode', String(settings.debugMode));
+}
+exports.setAdvancedSettings = setAdvancedSettings;
 /**
  * Get all app settings
  */
@@ -91,12 +374,26 @@ function getAppSettings() {
     return {
         editor: getEditorSettings(),
         browser: getBrowserSettings(),
+        display: getDisplaySettings(),
+        appearance: getAppearanceSettings(),
+        behavior: getBehaviorSettings(),
+        advanced: getAdvancedSettings(),
     };
 }
+exports.getAppSettings = getAppSettings;
 /**
  * Set all app settings
  */
 function setAppSettings(settings) {
     setEditorSettings(settings.editor);
     setBrowserSettings(settings.browser);
+    if (settings.display)
+        setDisplaySettings(settings.display);
+    if (settings.appearance)
+        setAppearanceSettings(settings.appearance);
+    if (settings.behavior)
+        setBehaviorSettings(settings.behavior);
+    if (settings.advanced)
+        setAdvancedSettings(settings.advanced);
 }
+exports.setAppSettings = setAppSettings;

package/dist/electron/core/workspace-utils.d.ts

@@ -0,0 +1,37 @@
+export interface WorkspaceFolder {
+    path: string;
+    name?: string;
+}
+export interface WorkspaceSettings {
+    [key: string]: any;
+}
+export interface WorkspaceExtensions {
+    recommendations?: string[];
+    unwantedRecommendations?: string[];
+}
+export interface ParsedWorkspace {
+    folders: WorkspaceFolder[];
+    settings?: WorkspaceSettings;
+    extensions?: WorkspaceExtensions;
+}
+/**
+ * Parse a .code-workspace file
+ * @param filePath Path to the .code-workspace file
+ * @returns Parsed workspace structure
+ */
+export declare function parseWorkspaceFile(filePath: string): ParsedWorkspace;
+/**
+ * Generate a .code-workspace file
+ * @param workspaceName Name of the workspace (used in comments)
+ * @param projects Array of project paths (absolute or relative)
+ * @param outputPath Path where the .code-workspace file should be created
+ * @param settings Optional workspace settings
+ * @param extensions Optional workspace extensions recommendations
+ */
+export declare function generateWorkspaceFile(workspaceName: string, projects: string[], outputPath: string, settings?: WorkspaceSettings, extensions?: WorkspaceExtensions): void;
+/**
+ * Validate that a path is a valid workspace file
+ * @param filePath Path to check
+ * @returns true if the path exists and is a valid .code-workspace file
+ */
+export declare function validateWorkspacePath(filePath: string): boolean;