ccmanager 2.8.0 → 2.9.1

package/dist/services/configurationManager.js

@@ -1,7 +1,9 @@
 import { homedir } from 'os';
 import { join } from 'path';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { Effect, Either } from 'effect';
 import { DEFAULT_SHORTCUTS, } from '../types/index.js';
+import { FileSystemError, ConfigError, ValidationError, } from '../types/errors.js';
 export class ConfigurationManager {
     constructor() {
         Object.defineProperty(this, "configPath", {
@@ -268,5 +270,249 @@ export class ConfigurationManager {
         presets.selectPresetOnStart = enabled;
         this.setCommandPresets(presets);
     }
+    // Effect-based methods for type-safe error handling
+    /**
+     * Load configuration from file with Effect-based error handling
+     *
+     * @returns {Effect.Effect<ConfigurationData, FileSystemError | ConfigError, never>} Configuration data on success, errors on failure
+     *
+     * @example
+     * ```typescript
+     * const result = await Effect.runPromise(
+     *   configManager.loadConfigEffect()
+     * );
+     * ```
+     */
+    loadConfigEffect() {
+        return Effect.try({
+            try: () => {
+                // Try to load the new config file
+                if (existsSync(this.configPath)) {
+                    const configData = readFileSync(this.configPath, 'utf-8');
+                    const parsedConfig = JSON.parse(configData);
+                    return this.applyDefaults(parsedConfig);
+                }
+                else {
+                    // If new config doesn't exist, check for legacy shortcuts.json
+                    const migratedConfig = this.migrateLegacyShortcutsSync();
+                    return this.applyDefaults(migratedConfig || {});
+                }
+            },
+            catch: (error) => {
+                // Determine error type
+                if (error instanceof SyntaxError) {
+                    return new ConfigError({
+                        configPath: this.configPath,
+                        reason: 'parse',
+                        details: String(error),
+                    });
+                }
+                return new FileSystemError({
+                    operation: 'read',
+                    path: this.configPath,
+                    cause: String(error),
+                });
+            },
+        });
+    }
+    /**
+     * Save configuration to file with Effect-based error handling
+     *
+     * @returns {Effect.Effect<void, FileSystemError, never>} Void on success, FileSystemError on write failure
+     *
+     * @example
+     * ```typescript
+     * await Effect.runPromise(
+     *   configManager.saveConfigEffect(config)
+     * );
+     * ```
+     */
+    saveConfigEffect(config) {
+        return Effect.try({
+            try: () => {
+                this.config = config;
+                writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+            },
+            catch: (error) => {
+                return new FileSystemError({
+                    operation: 'write',
+                    path: this.configPath,
+                    cause: String(error),
+                });
+            },
+        });
+    }
+    /**
+     * Validate configuration structure
+     * Synchronous validation using Either
+     */
+    validateConfig(config) {
+        if (!config || typeof config !== 'object') {
+            return Either.left(new ValidationError({
+                field: 'config',
+                constraint: 'must be a valid configuration object',
+                receivedValue: config,
+            }));
+        }
+        // Validate shortcuts field if present
+        const configObj = config;
+        if (configObj['shortcuts'] !== undefined &&
+            (typeof configObj['shortcuts'] !== 'object' ||
+                configObj['shortcuts'] === null)) {
+            return Either.left(new ValidationError({
+                field: 'config',
+                constraint: 'shortcuts must be a valid object',
+                receivedValue: config,
+            }));
+        }
+        // Additional validation could go here
+        return Either.right(config);
+    }
+    /**
+     * Get preset by ID with Either-based error handling
+     * Synchronous lookup using Either
+     */
+    getPresetByIdEffect(id) {
+        const presets = this.getCommandPresets();
+        const preset = presets.presets.find(p => p.id === id);
+        if (!preset) {
+            return Either.left(new ValidationError({
+                field: 'presetId',
+                constraint: 'Preset not found',
+                receivedValue: id,
+            }));
+        }
+        return Either.right(preset);
+    }
+    /**
+     * Set shortcuts with Effect-based error handling
+     *
+     * @returns {Effect.Effect<void, FileSystemError, never>} Void on success, FileSystemError on save failure
+     *
+     * @example
+     * ```typescript
+     * await Effect.runPromise(
+     *   configManager.setShortcutsEffect(shortcuts)
+     * );
+     * ```
+     */
+    setShortcutsEffect(shortcuts) {
+        this.config.shortcuts = shortcuts;
+        return this.saveConfigEffect(this.config);
+    }
+    /**
+     * Set command presets with Effect-based error handling
+     */
+    setCommandPresetsEffect(presets) {
+        this.config.commandPresets = presets;
+        return this.saveConfigEffect(this.config);
+    }
+    /**
+     * Add or update preset with Effect-based error handling
+     */
+    addPresetEffect(preset) {
+        const presets = this.getCommandPresets();
+        // Replace if exists, otherwise add
+        const existingIndex = presets.presets.findIndex(p => p.id === preset.id);
+        if (existingIndex >= 0) {
+            presets.presets[existingIndex] = preset;
+        }
+        else {
+            presets.presets.push(preset);
+        }
+        return this.setCommandPresetsEffect(presets);
+    }
+    /**
+     * Delete preset with Effect-based error handling
+     */
+    deletePresetEffect(id) {
+        const presets = this.getCommandPresets();
+        // Don't delete if it's the last preset
+        if (presets.presets.length <= 1) {
+            return Effect.fail(new ValidationError({
+                field: 'presetId',
+                constraint: 'Cannot delete last preset',
+                receivedValue: id,
+            }));
+        }
+        // Remove the preset
+        presets.presets = presets.presets.filter(p => p.id !== id);
+        // Update default if needed
+        if (presets.defaultPresetId === id && presets.presets.length > 0) {
+            presets.defaultPresetId = presets.presets[0].id;
+        }
+        return this.setCommandPresetsEffect(presets);
+    }
+    /**
+     * Set default preset with Effect-based error handling
+     */
+    setDefaultPresetEffect(id) {
+        const presets = this.getCommandPresets();
+        // Only update if preset exists
+        if (!presets.presets.some(p => p.id === id)) {
+            return Effect.fail(new ValidationError({
+                field: 'presetId',
+                constraint: 'Preset not found',
+                receivedValue: id,
+            }));
+        }
+        presets.defaultPresetId = id;
+        return this.setCommandPresetsEffect(presets);
+    }
+    // Helper methods
+    /**
+     * Apply default values to configuration
+     */
+    applyDefaults(config) {
+        // Ensure default values
+        if (!config.shortcuts) {
+            config.shortcuts = DEFAULT_SHORTCUTS;
+        }
+        if (!config.statusHooks) {
+            config.statusHooks = {};
+        }
+        if (!config.worktreeHooks) {
+            config.worktreeHooks = {};
+        }
+        if (!config.worktree) {
+            config.worktree = {
+                autoDirectory: false,
+                copySessionData: true,
+            };
+        }
+        if (!Object.prototype.hasOwnProperty.call(config.worktree, 'copySessionData')) {
+            config.worktree.copySessionData = true;
+        }
+        if (!config.command) {
+            config.command = {
+                command: 'claude',
+            };
+        }
+        return config;
+    }
+    /**
+     * Synchronous legacy shortcuts migration helper
+     */
+    migrateLegacyShortcutsSync() {
+        if (existsSync(this.legacyShortcutsPath)) {
+            try {
+                const shortcutsData = readFileSync(this.legacyShortcutsPath, 'utf-8');
+                const shortcuts = JSON.parse(shortcutsData);
+                // Validate that it's a valid shortcuts config
+                if (shortcuts && typeof shortcuts === 'object') {
+                    const config = { shortcuts };
+                    // Save to new config format
+                    this.config = config;
+                    writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+                    console.log('Migrated shortcuts from legacy shortcuts.json to config.json');
+                    return config;
+                }
+            }
+            catch (error) {
+                console.error('Failed to migrate legacy shortcuts:', error);
+            }
+        }
+        return null;
+    }
 }
 export const configurationManager = new ConfigurationManager();

package/dist/services/globalSessionOrchestrator.test.js

@@ -35,14 +35,6 @@ vi.mock('./sessionManager.js', () => {
         emit() {
             // Mock implementation
         }
-        async createSessionWithPreset(_worktreePath, _presetId) {
-            // Mock implementation
-            return {};
-        }
-        async createSessionWithDevcontainer(_worktreePath, _config, _presetId) {
-            // Mock implementation
-            return {};
-        }
     }
     return { SessionManager: MockSessionManager };
 });

package/dist/services/projectManager.d.ts

@@ -1,4 +1,6 @@
 import { GitProject, IProjectManager, IWorktreeService, MenuMode, RecentProject } from '../types/index.js';
+import { Effect } from 'effect';
+import { FileSystemError, ConfigError } from '../types/errors.js';
 export declare class ProjectManager implements IProjectManager {
     currentMode: MenuMode;
     currentProject?: GitProject;
@@ -15,7 +17,6 @@ export declare class ProjectManager implements IProjectManager {
     setMode(mode: MenuMode): void;
     selectProject(project: GitProject): void;
     getWorktreeService(projectPath?: string): IWorktreeService;
-    refreshProjects(): Promise<void>;
     isMultiProjectEnabled(): boolean;
     getProjectsDir(): string | undefined;
     getCurrentProjectPath(): string;
@@ -26,7 +27,6 @@ export declare class ProjectManager implements IProjectManager {
     getRecentProjects(limit?: number): RecentProject[];
     addRecentProject(project: GitProject): void;
     clearRecentProjects(): void;
-    discoverProjects(projectsDir: string): Promise<GitProject[]>;
     /**
      * Fast directory discovery - similar to ghq's approach
      */
@@ -50,6 +50,102 @@ export declare class ProjectManager implements IProjectManager {
     validateGitRepository(projectPath: string): Promise<boolean>;
     getCachedProject(projectPath: string): GitProject | undefined;
     refreshProject(projectPath: string): Promise<GitProject | null>;
+    /**
+     * Discover Git projects in the specified directory using Effect
+     *
+     * Recursively scans the directory for Git repositories with parallel processing.
+     * Caches results for improved performance.
+     *
+     * @param {string} projectsDir - Root directory to search for Git projects
+     * @returns {Effect.Effect<GitProject[], FileSystemError, never>} Effect containing discovered projects or FileSystemError
+     *
+     * @example
+     * ```typescript
+     * import {Effect} from 'effect';
+     * import {projectManager} from './services/projectManager.js';
+     *
+     * // Discover projects with error handling
+     * const projects = await Effect.runPromise(
+     *   Effect.catchAll(
+     *     projectManager.instance.discoverProjectsEffect('/home/user/projects'),
+     *     (error) => {
+     *       console.error(`Discovery failed: ${error.cause}`);
+     *       return Effect.succeed([]); // Return empty array on error
+     *     }
+     *   )
+     * );
+     *
+     * console.log(`Found ${projects.length} git repositories`);
+     * ```
+     */
+    discoverProjectsEffect(projectsDir: string): Effect.Effect<GitProject[], FileSystemError, never>;
+    /**
+     * Load recent projects from cache using Effect
+     *
+     * Reads and parses the recent projects JSON file. Returns empty array if file doesn't exist.
+     *
+     * @returns {Effect.Effect<RecentProject[], FileSystemError | ConfigError, never>} Effect containing recent projects or error
+     *
+     * @example
+     * ```typescript
+     * import {Effect} from 'effect';
+     * import {projectManager} from './services/projectManager.js';
+     *
+     * // Load recent projects with error handling
+     * const recent = await Effect.runPromise(
+     *   Effect.match(
+     *     projectManager.instance.loadRecentProjectsEffect(),
+     *     {
+     *       onFailure: (error) => {
+     *         if (error._tag === 'ConfigError') {
+     *           console.error(`Parse error: ${error.details}`);
+     *         } else {
+     *           console.error(`File error: ${error.cause}`);
+     *         }
+     *         return [];
+     *       },
+     *       onSuccess: (projects) => projects
+     *     }
+     *   )
+     * );
+     * ```
+     */
+    loadRecentProjectsEffect(): Effect.Effect<RecentProject[], FileSystemError | ConfigError, never>;
+    /**
+     * Save recent projects to cache using Effect
+     *
+     * Writes the recent projects array to JSON file.
+     *
+     * @param {RecentProject[]} projects - Recent projects to save
+     * @returns {Effect.Effect<void, FileSystemError, never>} Effect that succeeds or fails with FileSystemError
+     *
+     * @example
+     * ```typescript
+     * import {Effect} from 'effect';
+     * import {projectManager} from './services/projectManager.js';
+     *
+     * const recentProjects = [
+     *   { path: '/home/user/project1', name: 'project1', lastAccessed: Date.now() }
+     * ];
+     *
+     * // Save with error recovery
+     * await Effect.runPromise(
+     *   Effect.catchAll(
+     *     projectManager.instance.saveRecentProjectsEffect(recentProjects),
+     *     (error) => {
+     *       console.error(`Failed to save: ${error.cause}`);
+     *       return Effect.void; // Continue despite error
+     *     }
+     *   )
+     * );
+     * ```
+     */
+    saveRecentProjectsEffect(projects: RecentProject[]): Effect.Effect<void, FileSystemError, never>;
+    /**
+     * Refresh projects list (Effect version)
+     * @returns Effect with void or FileSystemError
+     */
+    refreshProjectsEffect(): Effect.Effect<void, FileSystemError, never>;
 }
 export declare const projectManager: {
     readonly instance: ProjectManager;