ccmanager 3.3.2 → 3.5.0

package/dist/services/config/globalConfigManager.js

@@ -0,0 +1,216 @@
+/**
+ * @internal
+ * This module is for internal use within the config directory only.
+ * External code should use ConfigEditor or ConfigReader instead.
+ */
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { DEFAULT_SHORTCUTS, } from '../../types/index.js';
+class GlobalConfigManager {
+    constructor() {
+        Object.defineProperty(this, "configPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "legacyShortcutsPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "configDir", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        // Determine config directory based on platform
+        const homeDir = homedir();
+        this.configDir =
+            process.platform === 'win32'
+                ? join(process.env['APPDATA'] || join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
+                : join(homeDir, '.config', 'ccmanager');
+        // Ensure config directory exists
+        if (!existsSync(this.configDir)) {
+            mkdirSync(this.configDir, { recursive: true });
+        }
+        this.configPath = join(this.configDir, 'config.json');
+        this.legacyShortcutsPath = join(this.configDir, 'shortcuts.json');
+        this.loadConfig();
+    }
+    loadConfig() {
+        // Try to load the new config file
+        if (existsSync(this.configPath)) {
+            try {
+                const configData = readFileSync(this.configPath, 'utf-8');
+                this.config = JSON.parse(configData);
+            }
+            catch (error) {
+                console.error('Failed to load configuration:', error);
+                this.config = {};
+            }
+        }
+        else {
+            // If new config doesn't exist, check for legacy shortcuts.json
+            this.migrateLegacyShortcuts();
+        }
+        // Check if shortcuts need to be loaded from legacy file
+        // This handles the case where config.json exists but doesn't have shortcuts
+        if (!this.config.shortcuts && existsSync(this.legacyShortcutsPath)) {
+            this.migrateLegacyShortcuts();
+        }
+        // Ensure default values
+        if (!this.config.shortcuts) {
+            this.config.shortcuts = DEFAULT_SHORTCUTS;
+        }
+        if (!this.config.statusHooks) {
+            this.config.statusHooks = {};
+        }
+        if (!this.config.worktreeHooks) {
+            this.config.worktreeHooks = {};
+        }
+        if (!this.config.worktree) {
+            this.config.worktree = {
+                autoDirectory: false,
+                copySessionData: true,
+                sortByLastSession: false,
+            };
+        }
+        if (!Object.prototype.hasOwnProperty.call(this.config.worktree, 'copySessionData')) {
+            this.config.worktree.copySessionData = true;
+        }
+        if (!Object.prototype.hasOwnProperty.call(this.config.worktree, 'sortByLastSession')) {
+            this.config.worktree.sortByLastSession = false;
+        }
+        if (!this.config.autoApproval) {
+            this.config.autoApproval = {
+                enabled: false,
+                timeout: 30,
+            };
+        }
+        else {
+            if (!Object.prototype.hasOwnProperty.call(this.config.autoApproval, 'enabled')) {
+                this.config.autoApproval.enabled = false;
+            }
+            if (!Object.prototype.hasOwnProperty.call(this.config.autoApproval, 'timeout')) {
+                this.config.autoApproval.timeout = 30;
+            }
+        }
+        // Migrate legacy command config to presets if needed
+        this.ensureDefaultPresets();
+    }
+    migrateLegacyShortcuts() {
+        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') {
+                    this.config.shortcuts = shortcuts;
+                    // Save to new config format
+                    this.saveConfig();
+                    console.log('Migrated shortcuts from legacy shortcuts.json to config.json');
+                }
+            }
+            catch (error) {
+                console.error('Failed to migrate legacy shortcuts:', error);
+            }
+        }
+    }
+    saveConfig() {
+        try {
+            const jsonData = JSON.stringify(this.config, null, 2);
+            writeFileSync(this.configPath, jsonData);
+            // Re-parse to ensure in-memory state matches what was written to disk
+            this.config = JSON.parse(jsonData);
+        }
+        catch (error) {
+            console.error('Failed to save configuration:', error);
+        }
+    }
+    getShortcuts() {
+        return this.config.shortcuts || DEFAULT_SHORTCUTS;
+    }
+    setShortcuts(shortcuts) {
+        this.config.shortcuts = shortcuts;
+        this.saveConfig();
+    }
+    getStatusHooks() {
+        return this.config.statusHooks || {};
+    }
+    setStatusHooks(hooks) {
+        this.config.statusHooks = hooks;
+        this.saveConfig();
+    }
+    getWorktreeHooks() {
+        return this.config.worktreeHooks || {};
+    }
+    setWorktreeHooks(hooks) {
+        this.config.worktreeHooks = hooks;
+        this.saveConfig();
+    }
+    getWorktreeConfig() {
+        return (this.config.worktree || {
+            autoDirectory: false,
+        });
+    }
+    setWorktreeConfig(worktreeConfig) {
+        this.config.worktree = worktreeConfig;
+        this.saveConfig();
+    }
+    getAutoApprovalConfig() {
+        const config = this.config.autoApproval || {
+            enabled: false,
+        };
+        // Default timeout to 30 seconds if not set
+        return {
+            ...config,
+            timeout: config.timeout ?? 30,
+        };
+    }
+    setAutoApprovalConfig(autoApproval) {
+        this.config.autoApproval = autoApproval;
+        this.saveConfig();
+    }
+    ensureDefaultPresets() {
+        // Ensure default presets if none exist
+        if (!this.config.commandPresets) {
+            this.config.commandPresets = {
+                presets: [
+                    {
+                        id: '1',
+                        name: 'Main',
+                        command: 'claude',
+                    },
+                ],
+                defaultPresetId: '1',
+            };
+        }
+    }
+    getCommandPresets() {
+        if (!this.config.commandPresets) {
+            this.ensureDefaultPresets();
+        }
+        return this.config.commandPresets;
+    }
+    setCommandPresets(presets) {
+        this.config.commandPresets = presets;
+        this.saveConfig();
+    }
+    /**
+     * Reload configuration from disk
+     */
+    reload() {
+        this.loadConfig();
+    }
+}
+export const globalConfigManager = new GlobalConfigManager();

package/dist/services/config/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Config module - handles global and project-level configuration.
+ *
+ * Public API:
+ * - ConfigEditor: For editing configuration (scope-aware)
+ * - ConfigReader: For reading merged configuration
+ * - createConfigEditor: Factory function to create ConfigEditor instances
+ *
+ * Note: globalConfigManager and projectConfigManager are internal
+ * and should not be imported directly from outside this directory.
+ */
+export { ConfigEditor, createConfigEditor } from './configEditor.js';
+export { ConfigReader, configReader } from './configReader.js';

package/dist/services/config/index.js

@@ -0,0 +1,13 @@
+/**
+ * Config module - handles global and project-level configuration.
+ *
+ * Public API:
+ * - ConfigEditor: For editing configuration (scope-aware)
+ * - ConfigReader: For reading merged configuration
+ * - createConfigEditor: Factory function to create ConfigEditor instances
+ *
+ * Note: globalConfigManager and projectConfigManager are internal
+ * and should not be imported directly from outside this directory.
+ */
+export { ConfigEditor, createConfigEditor } from './configEditor.js';
+export { ConfigReader, configReader } from './configReader.js';

package/dist/services/config/projectConfigManager.d.ts

@@ -0,0 +1,41 @@
+import { ProjectConfigurationData, ShortcutConfig, StatusHookConfig, WorktreeHookConfig, WorktreeConfig, CommandPresetsConfig, IConfigEditor, AutoApprovalConfig } from '../../types/index.js';
+/**
+ * ProjectConfigManager handles project-specific configuration.
+ * Reads/writes from `<git repository root>/.ccmanager.json`.
+ * Implements IConfigEditor for consistent API with GlobalConfigManager.
+ */
+declare class ProjectConfigManager implements IConfigEditor {
+    private gitRoot;
+    private configPath;
+    private projectConfig;
+    constructor(cwd: string);
+    private loadProjectConfig;
+    private saveProjectConfig;
+    private ensureProjectConfig;
+    getShortcuts(): ShortcutConfig | undefined;
+    setShortcuts(value: ShortcutConfig): void;
+    getStatusHooks(): StatusHookConfig | undefined;
+    setStatusHooks(value: StatusHookConfig): void;
+    getWorktreeHooks(): WorktreeHookConfig | undefined;
+    setWorktreeHooks(value: WorktreeHookConfig): void;
+    getWorktreeConfig(): WorktreeConfig | undefined;
+    setWorktreeConfig(value: WorktreeConfig): void;
+    getCommandPresets(): CommandPresetsConfig | undefined;
+    setCommandPresets(value: CommandPresetsConfig): void;
+    getAutoApprovalConfig(): AutoApprovalConfig | undefined;
+    setAutoApprovalConfig(value: AutoApprovalConfig): void;
+    reload(): void;
+    /**
+     * Check if a specific field has a project-level override
+     */
+    hasOverride(field: keyof ProjectConfigurationData): boolean;
+    /**
+     * Remove a project-level override for a specific field
+     */
+    removeOverride(field: keyof ProjectConfigurationData): void;
+}
+/**
+ * Default singleton instance using current working directory
+ */
+export declare const projectConfigManager: ProjectConfigManager;
+export {};

package/dist/services/config/projectConfigManager.js

@@ -0,0 +1,181 @@
+/**
+ * @internal
+ * This module is for internal use within the config directory only.
+ * External code should use ConfigEditor or ConfigReader instead.
+ */
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { ENV_VARS } from '../../constants/env.js';
+import { getGitRepositoryRoot } from '../../utils/gitUtils.js';
+const PROJECT_CONFIG_FILENAME = '.ccmanager.json';
+/**
+ * ProjectConfigManager handles project-specific configuration.
+ * Reads/writes from `<git repository root>/.ccmanager.json`.
+ * Implements IConfigEditor for consistent API with GlobalConfigManager.
+ */
+class ProjectConfigManager {
+    constructor(cwd) {
+        Object.defineProperty(this, "gitRoot", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "configPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "projectConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Use git repository root
+        this.gitRoot = getGitRepositoryRoot(cwd);
+        this.configPath = this.gitRoot
+            ? join(this.gitRoot, PROJECT_CONFIG_FILENAME)
+            : null;
+        this.loadProjectConfig();
+    }
+    loadProjectConfig() {
+        // In multi-project mode, skip project config to ensure global config is used
+        if (process.env[ENV_VARS.MULTI_PROJECT_ROOT]) {
+            this.projectConfig = null;
+            return;
+        }
+        // No git repository found
+        if (!this.configPath) {
+            this.projectConfig = null;
+            return;
+        }
+        if (existsSync(this.configPath)) {
+            try {
+                const data = readFileSync(this.configPath, 'utf-8');
+                this.projectConfig = JSON.parse(data);
+            }
+            catch {
+                this.projectConfig = null;
+            }
+        }
+        else {
+            this.projectConfig = null;
+        }
+    }
+    saveProjectConfig() {
+        if (this.projectConfig === null || !this.configPath) {
+            return;
+        }
+        try {
+            const jsonData = JSON.stringify(this.projectConfig, null, 2);
+            writeFileSync(this.configPath, jsonData);
+            // Re-parse to ensure in-memory state matches what was written to disk
+            this.projectConfig = JSON.parse(jsonData);
+        }
+        catch {
+            // Silently fail - error handling can be added later
+        }
+    }
+    ensureProjectConfig() {
+        if (this.projectConfig === null) {
+            this.projectConfig = {};
+        }
+        return this.projectConfig;
+    }
+    // IConfigEditor implementation
+    getShortcuts() {
+        return this.projectConfig?.shortcuts;
+    }
+    setShortcuts(value) {
+        const config = this.ensureProjectConfig();
+        config.shortcuts = value;
+        this.saveProjectConfig();
+    }
+    getStatusHooks() {
+        return this.projectConfig?.statusHooks;
+    }
+    setStatusHooks(value) {
+        const config = this.ensureProjectConfig();
+        config.statusHooks = value;
+        this.saveProjectConfig();
+    }
+    getWorktreeHooks() {
+        return this.projectConfig?.worktreeHooks;
+    }
+    setWorktreeHooks(value) {
+        const config = this.ensureProjectConfig();
+        config.worktreeHooks = value;
+        this.saveProjectConfig();
+    }
+    getWorktreeConfig() {
+        return this.projectConfig?.worktree;
+    }
+    setWorktreeConfig(value) {
+        const config = this.ensureProjectConfig();
+        config.worktree = value;
+        this.saveProjectConfig();
+    }
+    getCommandPresets() {
+        return this.projectConfig?.commandPresets;
+    }
+    setCommandPresets(value) {
+        const config = this.ensureProjectConfig();
+        config.commandPresets = value;
+        this.saveProjectConfig();
+    }
+    getAutoApprovalConfig() {
+        return this.projectConfig?.autoApproval;
+    }
+    setAutoApprovalConfig(value) {
+        const config = this.ensureProjectConfig();
+        config.autoApproval = value;
+        this.saveProjectConfig();
+    }
+    reload() {
+        this.loadProjectConfig();
+    }
+    // Project-specific helper methods
+    /**
+     * Check if a specific field has a project-level override
+     */
+    hasOverride(field) {
+        if (this.projectConfig === null) {
+            return false;
+        }
+        return this.projectConfig[field] !== undefined;
+    }
+    /**
+     * Remove a project-level override for a specific field
+     */
+    removeOverride(field) {
+        if (this.projectConfig === null || !this.configPath) {
+            return;
+        }
+        delete this.projectConfig[field];
+        // If project config is now empty, delete the file
+        if (Object.keys(this.projectConfig).length === 0) {
+            this.projectConfig = null;
+            try {
+                if (existsSync(this.configPath)) {
+                    unlinkSync(this.configPath);
+                }
+            }
+            catch {
+                // Silently fail
+            }
+        }
+        else {
+            this.saveProjectConfig();
+        }
+    }
+}
+/**
+ * Default singleton instance using current working directory
+ */
+export const projectConfigManager = new ProjectConfigManager(process.cwd());
+/**
+ * @internal - Exported for testing only
+ */
+export { ProjectConfigManager };

package/dist/services/config/projectConfigManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/config/projectConfigManager.test.js

@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { execSync } from 'child_process';
+// Mock fs module
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    mkdirSync: vi.fn(),
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    unlinkSync: vi.fn(),
+}));
+// Mock child_process module
+vi.mock('child_process', () => ({
+    execSync: vi.fn(),
+}));
+describe('ProjectConfigManager - git repository root', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    it('should read config from git repository root, not cwd', async () => {
+        const cwd = '/path/to/repo/subdir';
+        const gitRoot = '/path/to/repo';
+        const projectConfig = {
+            shortcuts: {
+                returnToMenu: { ctrl: true, key: 'r' },
+                cancel: { key: 'escape' },
+            },
+        };
+        // Mock git rev-parse to return the .git directory
+        execSync.mockReturnValue(`${gitRoot}/.git\n`);
+        // Mock existsSync to return true for the git root config path
+        existsSync.mockImplementation((path) => {
+            // Config exists at git root, not at cwd
+            return path === `${gitRoot}/.ccmanager.json`;
+        });
+        // Mock readFileSync to return project config
+        readFileSync.mockReturnValue(JSON.stringify(projectConfig));
+        // Dynamic import to pick up mocks
+        const { ProjectConfigManager } = await import('./projectConfigManager.js');
+        const manager = new ProjectConfigManager(cwd);
+        // Verify config was read from git root
+        const shortcuts = manager.getShortcuts();
+        expect(shortcuts).toEqual(projectConfig.shortcuts);
+        // Verify readFileSync was called with git root path
+        expect(readFileSync).toHaveBeenCalledWith(`${gitRoot}/.ccmanager.json`, 'utf-8');
+    });
+    it('should write config to git repository root, not cwd', async () => {
+        const cwd = '/path/to/repo/deep/nested/dir';
+        const gitRoot = '/path/to/repo';
+        // Mock git rev-parse
+        execSync.mockReturnValue(`${gitRoot}/.git\n`);
+        // No existing config
+        existsSync.mockReturnValue(false);
+        writeFileSync.mockImplementation(() => { });
+        const { ProjectConfigManager } = await import('./projectConfigManager.js');
+        const manager = new ProjectConfigManager(cwd);
+        // Set shortcuts to trigger a write
+        manager.setShortcuts({
+            returnToMenu: { ctrl: true, key: 'x' },
+            cancel: { key: 'q' },
+        });
+        // Verify writeFileSync was called with git root path
+        expect(writeFileSync).toHaveBeenCalledWith(`${gitRoot}/.ccmanager.json`, expect.any(String));
+    });
+    it('should handle worktree paths correctly', async () => {
+        const cwd = '/path/to/worktree';
+        const mainRepoRoot = '/path/to/main-repo';
+        const projectConfig = {
+            worktree: {
+                autoDirectory: true,
+            },
+        };
+        // Mock git rev-parse to return worktree .git path
+        execSync.mockReturnValue(`${mainRepoRoot}/.git/worktrees/my-worktree\n`);
+        existsSync.mockImplementation((path) => {
+            return path === `${mainRepoRoot}/.ccmanager.json`;
+        });
+        readFileSync.mockReturnValue(JSON.stringify(projectConfig));
+        const { ProjectConfigManager } = await import('./projectConfigManager.js');
+        const manager = new ProjectConfigManager(cwd);
+        // Verify config was read from main repo root
+        const worktreeConfig = manager.getWorktreeConfig();
+        expect(worktreeConfig).toEqual(projectConfig.worktree);
+        expect(readFileSync).toHaveBeenCalledWith(`${mainRepoRoot}/.ccmanager.json`, 'utf-8');
+    });
+    it('should return undefined when not in a git repository', async () => {
+        const cwd = '/not/a/git/repo';
+        // Mock git rev-parse to throw (not a git repo)
+        execSync.mockImplementation(() => {
+            throw new Error('fatal: not a git repository');
+        });
+        const { ProjectConfigManager } = await import('./projectConfigManager.js');
+        const manager = new ProjectConfigManager(cwd);
+        // Should return undefined for all getters
+        expect(manager.getShortcuts()).toBeUndefined();
+        expect(manager.getWorktreeConfig()).toBeUndefined();
+        expect(manager.getCommandPresets()).toBeUndefined();
+        // Should not attempt to read any file
+        expect(readFileSync).not.toHaveBeenCalled();
+    });
+});

package/dist/services/config/testUtils.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Test utilities for config module
+ *
+ * WARNING: This file is intended for TEST USE ONLY.
+ * Do not import from production code.
+ *
+ * These functions provide Effect-based wrappers for testing config operations.
+ */
+import { Effect, Either } from 'effect';
+import { ConfigurationData, CommandPreset, CommandPresetsConfig, ShortcutConfig, IConfigEditor } from '../../types/index.js';
+import { FileSystemError, ConfigError, ValidationError } from '../../types/errors.js';
+/**
+ * TEST ONLY: Load configuration from file with Effect-based error handling
+ *
+ * @param configPath - Path to the config file
+ * @param legacyShortcutsPath - Path to legacy shortcuts file for migration
+ * @returns Effect with ConfigurationData on success, errors on failure
+ */
+export declare function loadConfigEffect(configPath: string, legacyShortcutsPath: string): Effect.Effect<ConfigurationData, FileSystemError | ConfigError, never>;
+type ValidationResult = Either.Either<ConfigurationData, ValidationError>;
+/**
+ * TEST ONLY: Validate configuration structure
+ */
+export declare function validateConfig(config: unknown): ValidationResult;
+/**
+ * TEST ONLY: Add or update a preset in the config manager
+ */
+export declare function addPreset(configManager: IConfigEditor, preset: CommandPreset): void;
+/**
+ * TEST ONLY: Delete a preset by ID
+ */
+export declare function deletePreset(configManager: IConfigEditor, id: string): void;
+/**
+ * TEST ONLY: Set the default preset ID
+ */
+export declare function setDefaultPreset(configManager: IConfigEditor, id: string): void;
+/**
+ * TEST ONLY: Save configuration to file with Effect-based error handling
+ */
+export declare function saveConfigEffect(configManager: IConfigEditor, config: ConfigurationData, configPath: string): Effect.Effect<void, FileSystemError, never>;
+/**
+ * TEST ONLY: Set shortcuts with Effect-based error handling
+ */
+export declare function setShortcutsEffect(configManager: IConfigEditor, shortcuts: ShortcutConfig, configPath: string): Effect.Effect<void, FileSystemError, never>;
+/**
+ * TEST ONLY: Set command presets with Effect-based error handling
+ */
+export declare function setCommandPresetsEffect(configManager: IConfigEditor, presets: CommandPresetsConfig, configPath: string): Effect.Effect<void, FileSystemError, never>;
+/**
+ * TEST ONLY: Add or update preset with Effect-based error handling
+ */
+export declare function addPresetEffect(configManager: IConfigEditor, preset: CommandPreset, configPath: string): Effect.Effect<void, FileSystemError, never>;
+/**
+ * TEST ONLY: Delete preset with Effect-based error handling
+ */
+export declare function deletePresetEffect(configManager: IConfigEditor, id: string, configPath: string): Effect.Effect<void, ValidationError | FileSystemError, never>;
+/**
+ * TEST ONLY: Set default preset with Effect-based error handling
+ */
+export declare function setDefaultPresetEffect(configManager: IConfigEditor, id: string, configPath: string): Effect.Effect<void, ValidationError | FileSystemError, never>;
+/**
+ * TEST ONLY: Get the default preset
+ */
+export declare function getDefaultPreset(configManager: IConfigEditor): CommandPreset;
+/**
+ * TEST ONLY: Get whether to select preset on start
+ */
+export declare function getSelectPresetOnStart(configManager: IConfigEditor): boolean;
+/**
+ * TEST ONLY: Set whether to select preset on start
+ */
+export declare function setSelectPresetOnStart(configManager: IConfigEditor, enabled: boolean): void;
+/**
+ * TEST ONLY: Get whether auto-approval is enabled
+ */
+export declare function isAutoApprovalEnabled(configManager: IConfigEditor): boolean;
+/**
+ * TEST ONLY: Get preset by ID with Either-based error handling
+ */
+export declare function getPresetByIdEffect(configManager: IConfigEditor, id: string): Either.Either<CommandPreset, ValidationError>;
+export {};