@dx-pkg/mksymlink 1.0.4 → 1.0.7

package/src/commands/config.option-validator.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigOptionValidator = void 0;
-const symlink_error_1 = require("../services/symlink-error");
-const VALID_ACTIONS = ['get', 'set', 'unset', 'list'];
-class ConfigOptionValidator {
-    validate(options) {
-        this.validateAction(options.action);
-        this.validateKey(options.action, options.key);
-        this.validateValue(options.action, options.value);
-    }
-    validateAction(action) {
-        if (!VALID_ACTIONS.includes(action)) {
-            throw new symlink_error_1.SymlinkError(`Invalid config action: ${action}. Must be one of: ${VALID_ACTIONS.join(', ')}`, 'INVALID_CONFIG_ACTION');
-        }
-    }
-    validateKey(action, key) {
-        if (action === 'list') {
-            return; // list doesn't require a key
-        }
-        if (!key) {
-            throw new symlink_error_1.SymlinkError(`Key is required for '${action}' action`, 'MISSING_CONFIG_KEY');
-        }
-        if (typeof key !== 'string' || key.trim().length === 0) {
-            throw new symlink_error_1.SymlinkError(`Invalid config key: ${key}. Key must be a non-empty string.`, 'INVALID_CONFIG_KEY');
-        }
-    }
-    validateValue(action, value) {
-        if (action !== 'set') {
-            return; // only 'set' requires a value
-        }
-        if (!value) {
-            throw new symlink_error_1.SymlinkError(`Value is required for 'set' action`, 'MISSING_CONFIG_VALUE');
-        }
-        if (typeof value !== 'string') {
-            throw new symlink_error_1.SymlinkError(`Invalid config value: ${value}. Value must be a string.`, 'INVALID_CONFIG_VALUE');
-        }
-    }
-}
-exports.ConfigOptionValidator = ConfigOptionValidator;
-//# sourceMappingURL=config.option-validator.js.map

package/src/commands/create/mksymlink.command-factory.d.ts

@@ -1,5 +0,0 @@
-import { MkSymlinkCommand, MkSymlinkCommandOptions } from './mksymlink.command';
-export declare class MkSymlinkCommandFactory {
-    static create(options: MkSymlinkCommandOptions): MkSymlinkCommand;
-}
-//# sourceMappingURL=mksymlink.command-factory.d.ts.map

package/src/commands/create/mksymlink.option-validator.d.ts

@@ -1,9 +0,0 @@
-import { CommandOptionsValidator } from '../../types';
-import { MkSymlinkCommandOptions } from './mksymlink.command';
-export declare class MkSymlinkOptionValidator implements CommandOptionsValidator<MkSymlinkCommandOptions> {
-    validate(options: MkSymlinkCommandOptions): void;
-    private validateType;
-    private validateSource;
-    private validateForce;
-}
-//# sourceMappingURL=mksymlink.option-validator.d.ts.map

package/src/commands/index.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=index.d.ts.map

package/src/commands/mksymlink.command-factory.d.ts

@@ -1,5 +0,0 @@
-import { MkSymlinkCommand, MkSymlinkCommandOptions } from './create/mksymlink.command';
-export declare class MkSymlinkCommandFactory {
-    static create(options: MkSymlinkCommandOptions): MkSymlinkCommand;
-}
-//# sourceMappingURL=mksymlink.command-factory.d.ts.map

package/src/commands/mksymlink.command-factory.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MkSymlinkCommandFactory = void 0;
-const logger_1 = require("@dx-pkg/logger");
-const mksymlink_command_1 = require("./create/mksymlink.command");
-const mksymlink_option_validator_1 = require("./create/mksymlink.option-validator");
-const symlink_manager_1 = require("../services/symlink-manager");
-const platform_detector_1 = require("../services/platform-detector");
-class MkSymlinkCommandFactory {
-    static create(options) {
-        const validator = new mksymlink_option_validator_1.MkSymlinkOptionValidator();
-        validator.validate(options);
-        const logger = new logger_1.ConsoleLogger();
-        const osDetector = new platform_detector_1.PlatformDetector();
-        const symlinkManager = new symlink_manager_1.SymlinkService(logger, osDetector);
-        return new mksymlink_command_1.MkSymlinkCommand(logger, symlinkManager, options);
-    }
-}
-exports.MkSymlinkCommandFactory = MkSymlinkCommandFactory;
-//# sourceMappingURL=mksymlink.command-factory.js.map

package/src/commands/mksymlink.command.d.ts

@@ -1,22 +0,0 @@
-import { Logger } from '@dx-tools/logger';
-import { Command, WindowsSymlinkType, SymlinkOperations } from '../types';
-import { ConfigService } from '../services/config.service';
-export interface MkSymlinkCommandOptions {
-    target?: string;
-    source?: string;
-    type?: WindowsSymlinkType;
-    force?: boolean;
-    [key: string]: unknown;
-}
-export declare const SYMLINK_TYPES: readonly WindowsSymlinkType[];
-export declare class MkSymlinkCommand implements Command<MkSymlinkCommandOptions> {
-    private readonly logger;
-    private readonly symlinkManager;
-    private readonly options;
-    private readonly configService;
-    constructor(logger: Logger, symlinkManager: SymlinkOperations, options: MkSymlinkCommandOptions, configService?: ConfigService);
-    execute(): Promise<void>;
-    private resolveOptions;
-    private generateDefaultTarget;
-}
-//# sourceMappingURL=mksymlink.command.d.ts.map

package/src/commands/mksymlink.command.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MkSymlinkCommand = exports.SYMLINK_TYPES = void 0;
-const path_1 = require("path");
-const config_service_1 = require("../services/config.service");
-exports.SYMLINK_TYPES = ['file', 'dir', 'junction'];
-class MkSymlinkCommand {
-    logger;
-    symlinkManager;
-    options;
-    configService;
-    constructor(logger, symlinkManager, options, configService = new config_service_1.ConfigService()) {
-        this.logger = logger;
-        this.symlinkManager = symlinkManager;
-        this.options = options;
-        this.configService = configService;
-    }
-    async execute() {
-        try {
-            const { source, target, type, force } = this.resolveOptions();
-            this.logger.info('Creating symlink with options:');
-            this.logger.info(`  Source: ${source}`);
-            this.logger.info(`  Target: ${target}`);
-            this.logger.info(`  Type: ${type}`);
-            this.logger.info(`  Force: ${force}`);
-            const result = await this.symlinkManager.createSymlink({
-                source,
-                target,
-                type,
-                force,
-            });
-            if (!result.success) {
-                if (result.error) {
-                    throw result.error;
-                }
-                this.logger.warning(result.message || 'Symlink creation failed');
-                return;
-            }
-            this.logger.success('Symlink created successfully!');
-            this.logger.info(`  Source: ${result.source}`);
-            this.logger.info(`  Target: ${result.target}`);
-        }
-        catch (error) {
-            this.logger.error(`Failed to create symlink: ${error instanceof Error ? error.message : String(error)}`);
-            throw error;
-        }
-    }
-    resolveOptions() {
-        const currentDir = process.cwd();
-        const source = this.options.source || currentDir;
-        const target = this.options.target || this.generateDefaultTarget(currentDir);
-        const type = this.options.type || 'dir';
-        const force = this.options.force || false;
-        return { source, target, type, force };
-    }
-    generateDefaultTarget(currentDir) {
-        const currentBasename = (0, path_1.basename)(currentDir);
-        const parentDir = (0, path_1.dirname)(currentDir);
-        const parentBasename = (0, path_1.basename)(parentDir);
-        const symlinkName = `${parentBasename}--${currentBasename}`;
-        // Check if there's a configured default directory
-        const configuredDir = this.configService.getDefaultSymlinkDir();
-        const defaultSymlinkDir = configuredDir || currentDir;
-        return (0, path_1.resolve)(defaultSymlinkDir, symlinkName);
-    }
-}
-exports.MkSymlinkCommand = MkSymlinkCommand;
-//# sourceMappingURL=mksymlink.command.js.map

package/src/commands/mksymlink.option-validator.d.ts

@@ -1,9 +0,0 @@
-import { CommandOptionsValidator } from '../types';
-import { MkSymlinkCommandOptions } from './mksymlink.command';
-export declare class MkSymlinkOptionValidator implements CommandOptionsValidator<MkSymlinkCommandOptions> {
-    validate(options: MkSymlinkCommandOptions): void;
-    private validateType;
-    private validateSource;
-    private validateForce;
-}
-//# sourceMappingURL=mksymlink.option-validator.d.ts.map

package/src/commands/mksymlink.option-validator.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MkSymlinkOptionValidator = void 0;
-const symlink_error_1 = require("../services/symlink-error");
-const mksymlink_command_1 = require("./mksymlink.command");
-const fs_1 = require("fs");
-const path_1 = require("path");
-class MkSymlinkOptionValidator {
-    validate(options) {
-        this.validateType(options.type);
-        this.validateSource(options.source);
-        this.validateForce(options.force);
-    }
-    validateType(type) {
-        if (type && !mksymlink_command_1.SYMLINK_TYPES.includes(type)) {
-            throw new symlink_error_1.SymlinkError(`Invalid symlink type: ${type}. Must be one of: ${mksymlink_command_1.SYMLINK_TYPES.join(', ')}`, 'INVALID_SYMLINK_TYPE');
-        }
-    }
-    validateSource(source) {
-        if (!source) {
-            return;
-        }
-        const resolvedSource = (0, path_1.resolve)(source);
-        if (!(0, fs_1.existsSync)(resolvedSource)) {
-            throw new symlink_error_1.SymlinkError(`Source path does not exist: ${resolvedSource}`, 'SOURCE_NOT_FOUND');
-        }
-    }
-    validateForce(force) {
-        if (force !== undefined && typeof force !== 'boolean') {
-            throw new symlink_error_1.SymlinkError(`Invalid force option: ${force}. Must be a boolean.`, 'INVALID_FORCE_OPTION');
-        }
-    }
-}
-exports.MkSymlinkOptionValidator = MkSymlinkOptionValidator;
-//# sourceMappingURL=mksymlink.option-validator.js.map

package/src/index.d.ts

@@ -1,12 +0,0 @@
-export * from './types';
-export * from './services/platform-detector';
-export * from './services/symlink.service';
-export * from './services/symlink-error';
-export * from './services/config.service';
-export * from './commands/create/mksymlink.command';
-export * from './commands/create/mksymlink.option-validator';
-export * from './commands/create/mksymlink.command-factory';
-export * from './commands/config/config.command';
-export * from './commands/config/config.option-validator';
-export * from './commands/config/config.command-factory';
-//# sourceMappingURL=index.d.ts.map

package/src/services/config.service.d.ts

@@ -1,45 +0,0 @@
-export interface ConfigData {
-    [key: string]: string | undefined;
-}
-export declare class ConfigService {
-    private readonly configPath;
-    private config;
-    constructor(configPath?: string);
-    /**
-     * Get a configuration value by key
-     */
-    get(key: string): string | undefined;
-    /**
-     * Set a configuration value
-     */
-    set(key: string, value: string): void;
-    /**
-     * Unset (remove) a configuration value
-     */
-    unset(key: string): void;
-    /**
-     * List all configuration values
-     */
-    list(): ConfigData;
-    /**
-     * Get the default symlink directory from config
-     */
-    getDefaultSymlinkDir(): string | undefined;
-    /**
-     * Set the default symlink directory
-     */
-    setDefaultSymlinkDir(dir: string): void;
-    /**
-     * Get configuration file information
-     */
-    getConfigInfo(): {
-        path: string;
-        exists: boolean;
-        size?: number;
-        modified?: Date;
-        entries: number;
-    };
-    private loadConfig;
-    private saveConfig;
-}
-//# sourceMappingURL=config.service.d.ts.map

package/src/services/config.service.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigService = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const os_1 = require("os");
-class ConfigService {
-    configPath;
-    config = {};
-    constructor(configPath) {
-        const homeDir = (0, os_1.homedir)();
-        this.configPath = configPath || (0, path_1.resolve)(homeDir, '.mksymlinkrc');
-        this.loadConfig();
-    }
-    /**
-     * Get a configuration value by key
-     */
-    get(key) {
-        return this.config[key];
-    }
-    /**
-     * Set a configuration value
-     */
-    set(key, value) {
-        this.config[key] = value;
-        this.saveConfig();
-    }
-    /**
-     * Unset (remove) a configuration value
-     */
-    unset(key) {
-        delete this.config[key];
-        this.saveConfig();
-    }
-    /**
-     * List all configuration values
-     */
-    list() {
-        return { ...this.config };
-    }
-    /**
-     * Get the default symlink directory from config
-     */
-    getDefaultSymlinkDir() {
-        return this.get('symlink.defaultDir');
-    }
-    /**
-     * Set the default symlink directory
-     */
-    setDefaultSymlinkDir(dir) {
-        this.set('symlink.defaultDir', dir);
-    }
-    /**
-     * Get configuration file information
-     */
-    getConfigInfo() {
-        const exists = (0, fs_1.existsSync)(this.configPath);
-        const entries = Object.keys(this.config).length;
-        if (!exists) {
-            return {
-                path: this.configPath,
-                exists: false,
-                entries,
-            };
-        }
-        const stats = (0, fs_1.statSync)(this.configPath);
-        return {
-            path: this.configPath,
-            exists: true,
-            size: stats.size,
-            modified: stats.mtime,
-            entries,
-        };
-    }
-    loadConfig() {
-        if (!(0, fs_1.existsSync)(this.configPath)) {
-            this.config = {};
-            return;
-        }
-        try {
-            const content = (0, fs_1.readFileSync)(this.configPath, 'utf-8');
-            const lines = content.split('\n').filter((line) => line.trim());
-            this.config = {};
-            for (const line of lines) {
-                const [key, ...valueParts] = line.split('=');
-                if (key && valueParts.length > 0) {
-                    this.config[key.trim()] = valueParts.join('=').trim();
-                }
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to load config from ${this.configPath}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    saveConfig() {
-        try {
-            const configDir = (0, path_1.dirname)(this.configPath);
-            if (!(0, fs_1.existsSync)(configDir)) {
-                (0, fs_1.mkdirSync)(configDir, { recursive: true });
-            }
-            const content = Object.entries(this.config)
-                .filter(([, value]) => value !== undefined)
-                .map(([key, value]) => `${key}=${value}`)
-                .join('\n');
-            (0, fs_1.writeFileSync)(this.configPath, content + '\n', 'utf-8');
-        }
-        catch (error) {
-            throw new Error(`Failed to save config to ${this.configPath}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}
-exports.ConfigService = ConfigService;
-//# sourceMappingURL=config.service.js.map

package/src/services/os-detector.d.ts

@@ -1,11 +0,0 @@
-import { PlatformInformation, OSPlatform } from '../types';
-export declare class PlatformDetector implements PlatformInformation {
-    private readonly _platform;
-    constructor();
-    private normalizePlatform;
-    getPlatform(): OSPlatform;
-    isWindows(): boolean;
-    isMacOS(): boolean;
-    isLinux(): boolean;
-}
-//# sourceMappingURL=os-detector.d.ts.map

package/src/services/os-detector.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlatformDetector = void 0;
-const os_1 = require("os");
-class PlatformDetector {
-    _platform;
-    constructor() {
-        this._platform = this.normalizePlatform((0, os_1.platform)());
-    }
-    normalizePlatform(osPlatform) {
-        switch (osPlatform) {
-            case 'darwin':
-                return 'darwin';
-            case 'win32':
-                return 'win32';
-            case 'linux':
-                return 'linux';
-            default:
-                return 'unknown';
-        }
-    }
-    getPlatform() {
-        return this._platform;
-    }
-    isWindows() {
-        return this._platform === 'win32';
-    }
-    isMacOS() {
-        return this._platform === 'darwin';
-    }
-    isLinux() {
-        return this._platform === 'linux';
-    }
-}
-exports.PlatformDetector = PlatformDetector;
-//# sourceMappingURL=os-detector.js.map

package/src/services/platform-detector.d.ts

@@ -1,11 +0,0 @@
-import { PlatformInformation, OSPlatform } from '../types';
-export declare class PlatformDetector implements PlatformInformation {
-    private readonly _platform;
-    constructor();
-    private normalizePlatform;
-    getPlatform(): OSPlatform;
-    isWindows(): boolean;
-    isMacOS(): boolean;
-    isLinux(): boolean;
-}
-//# sourceMappingURL=platform-detector.d.ts.map

package/src/services/platform-detector.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlatformDetector = void 0;
-const os_1 = require("os");
-class PlatformDetector {
-    _platform;
-    constructor() {
-        this._platform = this.normalizePlatform((0, os_1.platform)());
-    }
-    normalizePlatform(osPlatform) {
-        switch (osPlatform) {
-            case 'darwin':
-                return 'darwin';
-            case 'win32':
-                return 'win32';
-            case 'linux':
-                return 'linux';
-            default:
-                return 'unknown';
-        }
-    }
-    getPlatform() {
-        return this._platform;
-    }
-    isWindows() {
-        return this._platform === 'win32';
-    }
-    isMacOS() {
-        return this._platform === 'darwin';
-    }
-    isLinux() {
-        return this._platform === 'linux';
-    }
-}
-exports.PlatformDetector = PlatformDetector;
-//# sourceMappingURL=platform-detector.js.map

package/src/services/symlink-error.d.ts

@@ -1,12 +0,0 @@
-import { Logger } from '@dx-pkg/logger';
-import { CommandError } from '../types';
-export declare class SymlinkError extends Error implements CommandError {
-    code?: string;
-    constructor(message: string, code?: string);
-}
-export declare class SymlinkErrorHandler {
-    private readonly logger;
-    constructor(logger: Logger);
-    handle(error: unknown): never;
-}
-//# sourceMappingURL=symlink-error.d.ts.map

package/src/services/symlink-error.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SymlinkErrorHandler = exports.SymlinkError = void 0;
-class SymlinkError extends Error {
-    code;
-    constructor(message, code) {
-        super(message);
-        this.name = 'SymlinkError';
-        this.code = code;
-        Error.captureStackTrace(this, this.constructor);
-    }
-}
-exports.SymlinkError = SymlinkError;
-class SymlinkErrorHandler {
-    logger;
-    constructor(logger) {
-        this.logger = logger;
-    }
-    handle(error) {
-        if (error instanceof SymlinkError) {
-            this.logger.error(`Symlink Error [${error.code || 'UNKNOWN'}]: ${error.message}`);
-            throw error;
-        }
-        if (error instanceof Error) {
-            this.logger.error(`Unexpected Error: ${error.message}`);
-            throw new SymlinkError(error.message, 'UNEXPECTED_ERROR');
-        }
-        this.logger.error(`Unknown Error: ${String(error)}`);
-        throw new SymlinkError(String(error), 'UNKNOWN_ERROR');
-    }
-}
-exports.SymlinkErrorHandler = SymlinkErrorHandler;
-//# sourceMappingURL=symlink-error.js.map

package/src/services/symlink-manager.d.ts

@@ -1,13 +0,0 @@
-import { Logger } from '@dx-pkg/logger';
-import { SymlinkOperations, SymlinkOptions, SymlinkResult, PlatformInformation } from '../types';
-export declare class SymlinkService implements SymlinkOperations {
-    private readonly logger;
-    private readonly osDetector;
-    constructor(logger: Logger, osDetector: PlatformInformation);
-    createSymlink(options: SymlinkOptions): Promise<SymlinkResult>;
-    private createWindowsSymlink;
-    private createUnixSymlink;
-    symlinkExists(path: string): Promise<boolean>;
-    removeSymlink(path: string): Promise<void>;
-}
-//# sourceMappingURL=symlink-manager.d.ts.map