claudedesk 4.3.1 → 4.4.0

package/dist/main/index.js

@@ -45,6 +45,10 @@ const history_manager_1 = require("./history-manager");
 const checkpoint_manager_1 = require("./checkpoint-manager");
 const agent_team_manager_1 = require("./agent-team-manager");
 const atlas_manager_1 = require("./atlas-manager");
+const layout_presets_manager_1 = require("./layout-presets-manager");
+const command_registry_1 = require("./command-registry");
+const model_history_manager_1 = require("./model-history-manager");
+const git_manager_1 = require("./git-manager");
 const ipc_handlers_1 = require("./ipc-handlers");
 // Check for dev mode via environment variable or if dist files don't exist
 const isDev = process.env.ELECTRON_IS_DEV === 'true' ||
@@ -58,6 +62,10 @@ let historyManager = null;
 let checkpointManager = null;
 let agentTeamManager = null;
 let atlasManager = null;
+let layoutPresetsManager = null;
+let commandRegistry = null;
+let modelHistoryManager = null;
+let gitManager = null;
 const CONFIG_DIR = path.join(electron_1.app.getPath('home'), '.claudedesk');
 const WINDOW_STATE_FILE = path.join(CONFIG_DIR, 'window-state.json');
 function ensureConfigDir() {
@@ -135,9 +143,11 @@ function createWindow() {
     }
     // Initialize managers
     settingsManager = new settings_persistence_1.SettingsManager();
+    layoutPresetsManager = new layout_presets_manager_1.LayoutPresetsManager(settingsManager);
     templatesManager = new prompt_templates_manager_1.PromptTemplatesManager();
     historyManager = new history_manager_1.HistoryManager();
     checkpointManager = new checkpoint_manager_1.CheckpointManager(historyManager);
+    modelHistoryManager = new model_history_manager_1.ModelHistoryManager();
     // Create session pool with config
     const poolSettings = settingsManager.getSessionPoolSettings();
     sessionPool = new session_pool_1.SessionPool({
@@ -147,6 +157,7 @@ function createWindow() {
     });
     // Create session manager with pool reference
     sessionManager = new session_manager_1.SessionManager(historyManager, sessionPool);
+    sessionManager.setModelHistoryManager(modelHistoryManager);
     sessionManager.initialize();
     // Validate split view state against current sessions
     const sessionList = sessionManager.listSessions();
@@ -155,6 +166,11 @@ function createWindow() {
     // Initialize atlas manager
     atlasManager = new atlas_manager_1.AtlasManager();
     atlasManager.setMainWindow(mainWindow);
+    // Initialize git manager
+    gitManager = new git_manager_1.GitManager(checkpointManager);
+    gitManager.setMainWindow(mainWindow);
+    // Initialize command registry
+    commandRegistry = new command_registry_1.CommandRegistry();
     // Initialize agent team manager
     agentTeamManager = new agent_team_manager_1.AgentTeamManager();
     agentTeamManager.setMainWindow(mainWindow);
@@ -164,7 +180,7 @@ function createWindow() {
         agentTeamManager?.onSessionClosed(sessionId);
     });
     // Setup IPC handlers with pool reference
-    (0, ipc_handlers_1.setupIPCHandlers)(mainWindow, sessionManager, settingsManager, templatesManager, historyManager, checkpointManager, sessionPool, agentTeamManager, atlasManager);
+    (0, ipc_handlers_1.setupIPCHandlers)(mainWindow, sessionManager, settingsManager, templatesManager, historyManager, checkpointManager, sessionPool, agentTeamManager, atlasManager, layoutPresetsManager, commandRegistry, modelHistoryManager, gitManager);
     // Initialize pool (delayed, async)
     setTimeout(() => {
         if (sessionPool) {
@@ -209,6 +225,14 @@ function createWindow() {
     });
     mainWindow.on('closed', () => {
         (0, ipc_handlers_1.removeIPCHandlers)();
+        if (modelHistoryManager) {
+            modelHistoryManager.shutdown();
+            modelHistoryManager = null;
+        }
+        if (gitManager) {
+            gitManager.destroy();
+            gitManager = null;
+        }
         if (atlasManager) {
             atlasManager.destroy();
             atlasManager = null;

package/dist/main/ipc-handlers.js

@@ -42,7 +42,7 @@ const quota_service_1 = require("./quota-service");
 const file_dragdrop_handler_1 = require("./file-dragdrop-handler");
 const ipc_registry_1 = require("./ipc-registry");
 let registry = null;
-function setupIPCHandlers(mainWindow, sessionManager, settingsManager, templatesManager, historyManager, checkpointManager, sessionPool, agentTeamManager, atlasManager) {
+function setupIPCHandlers(mainWindow, sessionManager, settingsManager, templatesManager, historyManager, checkpointManager, sessionPool, agentTeamManager, atlasManager, layoutPresetsManager, commandRegistry, modelHistoryManager, gitManager) {
     // Connect managers to window
     sessionManager.setMainWindow(mainWindow);
     checkpointManager.setMainWindow(mainWindow);
@@ -50,7 +50,8 @@ function setupIPCHandlers(mainWindow, sessionManager, settingsManager, templates
     // ── Session management (invoke) ──
     registry.handle('createSession', async (_e, request) => {
         try {
-            return await sessionManager.createSession(request);
+            const result = await sessionManager.createSession(request);
+            return result;
         }
         catch (err) {
             console.error('Failed to create session:', err);
@@ -65,7 +66,8 @@ function setupIPCHandlers(mainWindow, sessionManager, settingsManager, templates
     });
     registry.handle('renameSession', async (_e, sessionId, newName) => {
         try {
-            return await sessionManager.renameSession(sessionId, newName);
+            const result = await sessionManager.renameSession(sessionId, newName);
+            return result;
         }
         catch (err) {
             console.error('Failed to rename session:', err);
@@ -81,6 +83,47 @@ function setupIPCHandlers(mainWindow, sessionManager, settingsManager, templates
     registry.handle('getActiveSession', async () => {
         return sessionManager.getActiveSessionId();
     });
+    // ── Model switching ──
+    registry.handle('switchModel', async (_e, sessionId, model) => {
+        const session = sessionManager.getSession(sessionId);
+        console.log('[switchModel] Called with:', { sessionId, model, sessionStatus: session?.status });
+        if (!session) {
+            console.log('[switchModel] Session not found');
+            return false;
+        }
+        if (session.status === 'exited' || session.status === 'error') {
+            console.log('[switchModel] Session not active:', session.status);
+            return false;
+        }
+        const VALID_MODELS = ['opus', 'sonnet', 'haiku'];
+        if (!VALID_MODELS.includes(model)) {
+            console.log('[switchModel] Unknown model:', model);
+            return false;
+        }
+        const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+        // Use direct command syntax: /model haiku, /model sonnet, /model opus
+        // Type character-by-character to avoid autocomplete interference
+        const command = `/model ${model}`;
+        console.log('[switchModel] Typing command:', command);
+        for (const char of command) {
+            sessionManager.sendInput(sessionId, char);
+            await delay(50);
+        }
+        // Wait for autocomplete to settle
+        await delay(300);
+        // Press Enter to execute
+        sessionManager.sendInput(sessionId, '\r');
+        console.log('[switchModel] Command sent');
+        return true;
+    });
+    // ── Model History ──
+    registry.handle('getModelHistory', async (_e, sessionId) => {
+        return modelHistoryManager.getHistory(sessionId);
+    });
+    registry.handle('clearModelHistory', async (_e, sessionId) => {
+        modelHistoryManager.clearHistory(sessionId);
+        return true;
+    });
     // ── Dialogs ──
     registry.handle('browseDirectory', async () => {
         const result = await electron_1.dialog.showOpenDialog(mainWindow, {
@@ -239,6 +282,43 @@ function setupIPCHandlers(mainWindow, sessionManager, settingsManager, templates
             throw err;
         }
     });
+    // ── Commands ──
+    registry.handle('searchCommands', async (_e, query, maxResults = 10) => {
+        try {
+            return commandRegistry.search(query, maxResults);
+        }
+        catch (err) {
+            console.error('Failed to search commands:', err);
+            throw err;
+        }
+    });
+    registry.handle('getAllCommands', async () => {
+        try {
+            return commandRegistry.getAllCommands();
+        }
+        catch (err) {
+            console.error('Failed to get all commands:', err);
+            throw err;
+        }
+    });
+    registry.handle('executeCommand', async (_e, commandId, args) => {
+        try {
+            const command = commandRegistry.getCommand(commandId);
+            if (!command) {
+                console.error('Command not found:', commandId);
+                return false;
+            }
+            // Execute command action
+            // For now, commands with UI actions will be handled by the renderer
+            // This is a placeholder for future server-side command execution
+            console.log('Executing command:', commandId, args);
+            return true;
+        }
+        catch (err) {
+            console.error('Failed to execute command:', err);
+            return false;
+        }
+    });
     // ── Drag-Drop ──
     registry.handle('getFileInfo', async (_e, filePaths) => {
         try {
@@ -438,6 +518,26 @@ function setupIPCHandlers(mainWindow, sessionManager, settingsManager, templates
             return false;
         }
     });
+    registry.handle('updateUIMode', async (_e, mode) => {
+        try {
+            settingsManager.updateUIMode(mode);
+            return true;
+        }
+        catch (err) {
+            console.error('Failed to update UI mode:', err);
+            return false;
+        }
+    });
+    registry.handle('updateDefaultModel', async (_e, model) => {
+        try {
+            settingsManager.updateDefaultModel(model);
+            return true;
+        }
+        catch (err) {
+            console.error('Failed to update default model:', err);
+            return false;
+        }
+    });
     // ── Repository Atlas ──
     registry.handle('generateAtlas', async (_e, request) => {
         try {
@@ -476,6 +576,250 @@ function setupIPCHandlers(mainWindow, sessionManager, settingsManager, templates
             throw err;
         }
     });
+    // ── Layout Presets ──
+    registry.handle('getLayoutPresets', async () => {
+        return layoutPresetsManager.getPresets();
+    });
+    registry.handle('applyLayoutPreset', async (_e, presetId) => {
+        try {
+            const preset = layoutPresetsManager.getPresetById(presetId);
+            if (!preset) {
+                console.error('Preset not found:', presetId);
+                return false;
+            }
+            // Validate the preset structure
+            if (!layoutPresetsManager.validateLayout(preset.structure)) {
+                console.error('Invalid preset structure:', presetId);
+                return false;
+            }
+            // Update split view state with preset layout
+            settingsManager.updateSplitViewState({
+                layout: preset.structure,
+                focusedPaneId: '', // Will be set by renderer
+            });
+            // Save the last used preset ID
+            layoutPresetsManager.saveLastUsedPreset(presetId);
+            return true;
+        }
+        catch (err) {
+            console.error('Failed to apply layout preset:', err);
+            return false;
+        }
+    });
+    registry.handle('applyCustomLayout', async (_e, rows, cols) => {
+        try {
+            const customLayout = layoutPresetsManager.createCustomGridLayout(rows, cols);
+            // Validate the generated layout
+            if (!layoutPresetsManager.validateLayout(customLayout)) {
+                console.error('Invalid custom layout generated');
+                return false;
+            }
+            // Update split view state
+            settingsManager.updateSplitViewState({
+                layout: customLayout,
+                focusedPaneId: '', // Will be set by renderer
+            });
+            // Save as custom preset
+            layoutPresetsManager.saveLastUsedPreset('custom');
+            return true;
+        }
+        catch (err) {
+            console.error('Failed to apply custom layout:', err);
+            return false;
+        }
+    });
+    registry.handle('getCurrentLayout', async () => {
+        const settings = settingsManager.getSettings();
+        if (settings.splitViewState) {
+            return settings.splitViewState.layout;
+        }
+        // Return default single pane layout
+        const { v4: uuidv4 } = require('uuid');
+        const defaultLayout = {
+            type: 'leaf',
+            paneId: uuidv4(),
+            sessionId: null,
+        };
+        return defaultLayout;
+    });
+    // ── Git Integration ──
+    registry.handle('getGitStatus', async (_e, workDir) => {
+        try {
+            return await gitManager.getStatus(workDir);
+        }
+        catch (err) {
+            console.error('Failed to get git status:', err);
+            throw err;
+        }
+    });
+    registry.handle('getGitBranches', async (_e, workDir) => {
+        try {
+            return await gitManager.getBranches(workDir);
+        }
+        catch (err) {
+            console.error('Failed to get git branches:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitStageFiles', async (_e, workDir, files) => {
+        try {
+            return await gitManager.stageFiles(workDir, files);
+        }
+        catch (err) {
+            console.error('Failed to stage files:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitUnstageFiles', async (_e, workDir, files) => {
+        try {
+            return await gitManager.unstageFiles(workDir, files);
+        }
+        catch (err) {
+            console.error('Failed to unstage files:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitStageAll', async (_e, workDir) => {
+        try {
+            return await gitManager.stageAll(workDir);
+        }
+        catch (err) {
+            console.error('Failed to stage all:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitUnstageAll', async (_e, workDir) => {
+        try {
+            return await gitManager.unstageAll(workDir);
+        }
+        catch (err) {
+            console.error('Failed to unstage all:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitCommit', async (_e, request) => {
+        try {
+            return await gitManager.commit(request);
+        }
+        catch (err) {
+            console.error('Failed to commit:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitGenerateMessage', async (_e, workDir) => {
+        try {
+            return await gitManager.generateMessage(workDir);
+        }
+        catch (err) {
+            console.error('Failed to generate commit message:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitPush', async (_e, workDir, setUpstream) => {
+        try {
+            return await gitManager.push(workDir, setUpstream);
+        }
+        catch (err) {
+            console.error('Failed to push:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitPull', async (_e, workDir) => {
+        try {
+            return await gitManager.pull(workDir);
+        }
+        catch (err) {
+            console.error('Failed to pull:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitFetch', async (_e, workDir) => {
+        try {
+            return await gitManager.fetch(workDir);
+        }
+        catch (err) {
+            console.error('Failed to fetch:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitSwitchBranch', async (_e, workDir, branch) => {
+        try {
+            return await gitManager.switchBranch(workDir, branch);
+        }
+        catch (err) {
+            console.error('Failed to switch branch:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitCreateBranch', async (_e, workDir, branch) => {
+        try {
+            return await gitManager.createBranch(workDir, branch);
+        }
+        catch (err) {
+            console.error('Failed to create branch:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitLog', async (_e, workDir, count) => {
+        try {
+            return await gitManager.log(workDir, count);
+        }
+        catch (err) {
+            console.error('Failed to get git log:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitDiff', async (_e, workDir, filePath, staged) => {
+        try {
+            return await gitManager.diff(workDir, filePath, staged);
+        }
+        catch (err) {
+            console.error('Failed to get diff:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitCommitDiff', async (_e, workDir, hash) => {
+        try {
+            return await gitManager.commitDiff(workDir, hash);
+        }
+        catch (err) {
+            console.error('Failed to get commit diff:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitDiscardFile', async (_e, workDir, filePath) => {
+        try {
+            return await gitManager.discardFile(workDir, filePath);
+        }
+        catch (err) {
+            console.error('Failed to discard file:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitDiscardAll', async (_e, workDir) => {
+        try {
+            return await gitManager.discardAll(workDir);
+        }
+        catch (err) {
+            console.error('Failed to discard all:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitInit', async (_e, workDir) => {
+        try {
+            return await gitManager.init(workDir);
+        }
+        catch (err) {
+            console.error('Failed to init git:', err);
+            throw err;
+        }
+    });
+    registry.handle('gitStartWatching', async (_e, workDir) => {
+        return gitManager.startWatching(workDir);
+    });
+    registry.handle('gitStopWatching', async (_e, workDir) => {
+        return gitManager.stopWatching(workDir);
+    });
     // ── App info ──
     registry.handle('getVersionInfo', async () => {
         const { app } = require('electron');

package/dist/main/layout-presets-manager.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LayoutPresetsManager = void 0;
+const uuid_1 = require("uuid");
+const layout_presets_1 = require("../types/layout-presets");
+/**
+ * LayoutPresetsManager — Manages layout presets, custom grid generation, and validation.
+ */
+class LayoutPresetsManager {
+    constructor(settingsPersistence) {
+        this.settingsPersistence = settingsPersistence;
+        this.defaultPresets = this.buildDefaultPresets();
+    }
+    /**
+     * Get all available layout presets
+     */
+    getPresets() {
+        return this.defaultPresets;
+    }
+    /**
+     * Get a specific preset by ID
+     */
+    getPresetById(id) {
+        return this.defaultPresets.find(p => p.id === id) || null;
+    }
+    /**
+     * Generate a custom grid layout from rows and columns
+     */
+    createCustomGridLayout(rows, cols) {
+        // Validate inputs
+        if (rows < 1 || rows > 6 || cols < 1 || cols > 6) {
+            throw new Error('Rows and columns must be between 1 and 6');
+        }
+        // If single pane, return a leaf
+        if (rows === 1 && cols === 1) {
+            return this.createLeaf();
+        }
+        // If single row, create horizontal grid
+        if (rows === 1) {
+            return this.createHorizontalGrid(cols);
+        }
+        // If single column, create vertical grid
+        if (cols === 1) {
+            return this.createVerticalGrid(rows);
+        }
+        // Otherwise, create a grid of rows, each containing columns
+        const rowSize = 100 / rows;
+        const colSize = 100 / cols;
+        const rowChildren = [];
+        for (let r = 0; r < rows; r++) {
+            const colChildren = [];
+            for (let c = 0; c < cols; c++) {
+                colChildren.push(this.createLeaf());
+            }
+            // Create horizontal grid for this row
+            rowChildren.push({
+                type: 'grid',
+                id: (0, uuid_1.v4)(),
+                direction: 'horizontal',
+                children: colChildren,
+                sizes: new Array(cols).fill(colSize),
+            });
+        }
+        // Return vertical grid of rows
+        return {
+            type: 'grid',
+            id: (0, uuid_1.v4)(),
+            direction: 'vertical',
+            children: rowChildren,
+            sizes: new Array(rows).fill(rowSize),
+        };
+    }
+    /**
+     * Validate a layout structure
+     */
+    validateLayout(node) {
+        try {
+            return this.validateNode(node);
+        }
+        catch (err) {
+            console.error('Layout validation failed:', err);
+            return false;
+        }
+    }
+    /**
+     * Save the last used preset ID to settings
+     */
+    saveLastUsedPreset(presetId) {
+        try {
+            this.settingsPersistence.updateLastUsedLayoutPreset(presetId);
+        }
+        catch (err) {
+            console.error('Failed to save last used preset:', err);
+        }
+    }
+    // ── Private helpers ──
+    buildDefaultPresets() {
+        return [
+            {
+                id: layout_presets_1.PRESET_IDS.SINGLE,
+                name: 'Single Pane',
+                description: 'One full-width terminal',
+                shortcut: '1',
+                structure: this.createLeaf(),
+            },
+            {
+                id: layout_presets_1.PRESET_IDS.TWO_COLUMN,
+                name: '2-Column Layout',
+                description: 'Two terminals side-by-side',
+                shortcut: '2',
+                structure: this.createHorizontalGrid(2),
+            },
+            {
+                id: layout_presets_1.PRESET_IDS.THREE_COLUMN,
+                name: '3-Column Layout',
+                description: 'Three equal-width terminals',
+                shortcut: '3',
+                structure: this.createHorizontalGrid(3),
+            },
+            {
+                id: layout_presets_1.PRESET_IDS.QUAD_GRID,
+                name: '2×2 Grid',
+                description: 'Four terminals in a grid',
+                shortcut: '4',
+                structure: this.createQuadGrid(),
+            },
+            {
+                id: layout_presets_1.PRESET_IDS.CUSTOM,
+                name: 'Custom Layout',
+                description: 'Build your own grid',
+                shortcut: '5',
+                structure: this.createLeaf(), // Placeholder, overridden by builder
+                isCustom: true,
+            },
+        ];
+    }
+    createLeaf() {
+        return {
+            type: 'leaf',
+            paneId: (0, uuid_1.v4)(),
+            sessionId: null,
+        };
+    }
+    createHorizontalGrid(count) {
+        const size = 100 / count;
+        const children = [];
+        for (let i = 0; i < count; i++) {
+            children.push(this.createLeaf());
+        }
+        return {
+            type: 'grid',
+            id: (0, uuid_1.v4)(),
+            direction: 'horizontal',
+            children,
+            sizes: new Array(count).fill(size),
+        };
+    }
+    createVerticalGrid(count) {
+        const size = 100 / count;
+        const children = [];
+        for (let i = 0; i < count; i++) {
+            children.push(this.createLeaf());
+        }
+        return {
+            type: 'grid',
+            id: (0, uuid_1.v4)(),
+            direction: 'vertical',
+            children,
+            sizes: new Array(count).fill(size),
+        };
+    }
+    createQuadGrid() {
+        // 2×2 grid: vertical split of two horizontal splits
+        const topRow = {
+            type: 'grid',
+            id: (0, uuid_1.v4)(),
+            direction: 'horizontal',
+            children: [this.createLeaf(), this.createLeaf()],
+            sizes: [50, 50],
+        };
+        const bottomRow = {
+            type: 'grid',
+            id: (0, uuid_1.v4)(),
+            direction: 'horizontal',
+            children: [this.createLeaf(), this.createLeaf()],
+            sizes: [50, 50],
+        };
+        return {
+            type: 'grid',
+            id: (0, uuid_1.v4)(),
+            direction: 'vertical',
+            children: [topRow, bottomRow],
+            sizes: [50, 50],
+        };
+    }
+    validateNode(node) {
+        if (!node || typeof node !== 'object') {
+            return false;
+        }
+        if (node.type === 'leaf') {
+            return typeof node.paneId === 'string';
+        }
+        if (node.type === 'branch') {
+            return (typeof node.direction === 'string' &&
+                typeof node.ratio === 'number' &&
+                node.ratio >= 0 &&
+                node.ratio <= 1 &&
+                Array.isArray(node.children) &&
+                node.children.length === 2 &&
+                this.validateNode(node.children[0]) &&
+                this.validateNode(node.children[1]));
+        }
+        if (node.type === 'grid') {
+            if (typeof node.id !== 'string' ||
+                (node.direction !== 'horizontal' && node.direction !== 'vertical') ||
+                !Array.isArray(node.children) ||
+                !Array.isArray(node.sizes) ||
+                node.children.length !== node.sizes.length ||
+                node.children.length === 0) {
+                return false;
+            }
+            // Validate sizes sum to approximately 100
+            const sum = node.sizes.reduce((a, b) => a + b, 0);
+            if (Math.abs(sum - 100) > 0.5) {
+                return false;
+            }
+            // Validate all children
+            return node.children.every(child => this.validateNode(child));
+        }
+        return false;
+    }
+}
+exports.LayoutPresetsManager = LayoutPresetsManager;