@dx-pkg/mksymlink 1.0.7 → 1.0.9

package/examples/advanced-usage.d.ts

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

package/examples/advanced-usage.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../src");
+const logger_1 = require("@dx-pkg/logger");
+async function advancedExample() {
+    console.log('=== Advanced Symlink Manager Usage ===\n');
+    const logger = new logger_1.ConsoleLogger();
+    const osDetector = new src_1.PlatformDetector();
+    const symlinkManager = new src_1.SymlinkService(logger, osDetector);
+    console.log(`Detected OS: ${osDetector.getPlatform()}\n`);
+    const source = process.cwd();
+    const target = '/tmp/advanced-symlink';
+    console.log('Checking if symlink exists...');
+    const exists = await symlinkManager.symlinkExists(target);
+    console.log(`Symlink exists: ${exists}\n`);
+    if (exists) {
+        console.log('Removing existing symlink...');
+        await symlinkManager.removeSymlink(target);
+        console.log('Removed successfully\n');
+    }
+    console.log('Creating new symlink...');
+    const result = await symlinkManager.createSymlink({
+        source,
+        target,
+        type: osDetector.isWindows() ? 'junction' : 'dir',
+        force: false,
+    });
+    if (result.success) {
+        console.log('\nSymlink created successfully!');
+        console.log(`  Source: ${result.source}`);
+        console.log(`  Target: ${result.target}`);
+    }
+    else {
+        console.error('\nFailed to create symlink:');
+        console.error(`  ${result.message || result.error?.message}`);
+    }
+}
+advancedExample().catch(console.error);

package/examples/basic-usage.d.ts

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

package/examples/basic-usage.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../src");
+const path_1 = require("path");
+async function basicExample() {
+    console.log('=== Basic Symlink Creation ===\n');
+    const command = src_1.MkSymlinkCommandFactory.create({
+        source: process.cwd(),
+        target: (0, path_1.join)(process.cwd(), 'target-symlink'),
+        type: 'dir',
+    });
+    await command.execute();
+}
+basicExample().catch(console.error);

package/examples/config-usage.d.ts

@@ -0,0 +1,2 @@
+declare function configExamples(): Promise<void>;
+export { configExamples };

package/examples/config-usage.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configExamples = configExamples;
+const config_command_factory_1 = require("../src/commands/config/config.command-factory");
+const path_1 = require("path");
+const os_1 = require("os");
+async function configExamples() {
+    console.log('=== Config Command Examples ===\n');
+    try {
+        // Example 1: List all configuration
+        console.log('1. List all configuration:');
+        const listCommand = config_command_factory_1.ConfigCommandFactory.create({ action: 'list' });
+        await listCommand.execute();
+        console.log('');
+        // Example 2: Set default symlink directory
+        console.log('2. Set default symlink directory:');
+        const setCommand = config_command_factory_1.ConfigCommandFactory.create({
+            action: 'set',
+            key: 'symlink.defaultDir',
+            value: (0, path_1.join)((0, os_1.homedir)(), 'symlinks'),
+        });
+        await setCommand.execute();
+        console.log('');
+        // Example 3: Get a specific config value
+        console.log('3. Get default symlink directory:');
+        const getCommand = config_command_factory_1.ConfigCommandFactory.create({
+            action: 'get',
+            key: 'symlink.defaultDir',
+        });
+        await getCommand.execute();
+        console.log('');
+        // Example 4: Set a custom config key
+        console.log('4. Set a custom config key:');
+        const setCustomCommand = config_command_factory_1.ConfigCommandFactory.create({
+            action: 'set',
+            key: 'user.name',
+            value: 'John Doe',
+        });
+        await setCustomCommand.execute();
+        console.log('');
+        // Example 5: List all configuration again (to see changes)
+        console.log('5. List all configuration (after changes):');
+        const listCommand2 = config_command_factory_1.ConfigCommandFactory.create({ action: 'list' });
+        await listCommand2.execute();
+        console.log('');
+        // Example 6: Unset a config value
+        console.log('6. Unset user.name:');
+        const unsetCommand = config_command_factory_1.ConfigCommandFactory.create({
+            action: 'unset',
+            key: 'user.name',
+        });
+        await unsetCommand.execute();
+        console.log('');
+        // Example 7: List configuration one more time
+        console.log('7. List configuration (after unset):');
+        const listCommand3 = config_command_factory_1.ConfigCommandFactory.create({ action: 'list' });
+        await listCommand3.execute();
+        console.log('');
+        console.log('=== Config Examples Completed ===\n');
+    }
+    catch (error) {
+        console.error('Error running config examples:', error);
+    }
+}

package/examples/cross-platform.d.ts

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

package/examples/cross-platform.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../src");
+async function crossPlatformExample() {
+    console.log('=== Cross-Platform Symlink Example ===\n');
+    const osDetector = new src_1.PlatformDetector();
+    const platform = osDetector.getPlatform();
+    console.log(`Current platform: ${platform}`);
+    console.log(`Is Windows: ${osDetector.isWindows()}`);
+    console.log(`Is macOS: ${osDetector.isMacOS()}`);
+    console.log(`Is Linux: ${osDetector.isLinux()}\n`);
+    const source = process.cwd();
+    let target;
+    let type;
+    if (osDetector.isWindows()) {
+        target = 'C:\\temp\\my-symlink';
+        type = 'junction';
+        console.log('Using Windows junction for better compatibility\n');
+    }
+    else {
+        target = '/tmp/my-symlink';
+        type = 'dir';
+        console.log('Using standard directory symlink\n');
+    }
+    const command = src_1.MkSymlinkCommandFactory.create({
+        source,
+        target,
+        type,
+        force: true,
+    });
+    try {
+        await command.execute();
+        console.log('\nCross-platform symlink created successfully!');
+    }
+    catch (error) {
+        console.error('\nFailed to create symlink:');
+        console.error(error);
+    }
+}
+crossPlatformExample().catch(console.error);

package/examples/index.d.ts

@@ -0,0 +1 @@
+import './basic-usage';

package/examples/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./basic-usage");
+// import { configExamples } from './config-usage';
+// Uncomment to run config examples:
+// configExamples().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dx-pkg/mksymlink",
-    "version": "1.0.7",
+    "version": "1.0.9",
     "description": "Create symbolic links across platforms (macOS, Windows)",
     "type": "commonjs",
     "main": "./src/index.js",

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

@@ -0,0 +1,4 @@
+import { ConfigCommand, ConfigCommandOptions } from './config.command';
+export declare class ConfigCommandFactory {
+    static create(options: ConfigCommandOptions): ConfigCommand;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigCommandFactory = void 0;
+const logger_1 = require("@dx-pkg/logger");
+const config_command_1 = require("./config.command");
+const config_option_validator_1 = require("./config.option-validator");
+const config_service_1 = require("../../services/config.service");
+class ConfigCommandFactory {
+    static create(options) {
+        const validator = new config_option_validator_1.ConfigOptionValidator();
+        validator.validate(options);
+        const logger = new logger_1.ConsoleLogger();
+        const configService = new config_service_1.ConfigService();
+        return new config_command_1.ConfigCommand(logger, configService, options);
+    }
+}
+exports.ConfigCommandFactory = ConfigCommandFactory;

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

@@ -0,0 +1,22 @@
+import { Logger } from '@dx-pkg/logger';
+import { Command } from '../../types';
+import { ConfigService } from '../../services/config.service';
+export type ConfigAction = 'get' | 'set' | 'unset' | 'list' | 'info';
+export interface ConfigCommandOptions {
+    action: ConfigAction;
+    key?: string;
+    value?: string;
+    [key: string]: unknown;
+}
+export declare class ConfigCommand implements Command<ConfigCommandOptions> {
+    private readonly logger;
+    private readonly configService;
+    private readonly options;
+    constructor(logger: Logger, configService: ConfigService, options: ConfigCommandOptions);
+    execute(): Promise<void>;
+    private handleGet;
+    private handleSet;
+    private handleUnset;
+    private handleList;
+    private handleInfo;
+}

package/src/commands/config/config.command.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigCommand = void 0;
+class ConfigCommand {
+    logger;
+    configService;
+    options;
+    constructor(logger, configService, options) {
+        this.logger = logger;
+        this.configService = configService;
+        this.options = options;
+    }
+    async execute() {
+        try {
+            const { action, key, value } = this.options;
+            switch (action) {
+                case 'get':
+                    await this.handleGet(key);
+                    break;
+                case 'set':
+                    await this.handleSet(key, value);
+                    break;
+                case 'unset':
+                    await this.handleUnset(key);
+                    break;
+                case 'list':
+                    await this.handleList();
+                    break;
+                case 'info':
+                    await this.handleInfo();
+                    break;
+                default:
+                    throw new Error(`Unknown config action: ${action}`);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Config command failed: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+    }
+    async handleGet(key) {
+        if (!key) {
+            throw new Error('Key is required for get action');
+        }
+        const value = this.configService.get(key);
+        if (value === undefined) {
+            this.logger.warning(`Config key '${key}' not found`);
+            return;
+        }
+        this.logger.info(value);
+    }
+    async handleSet(key, value) {
+        if (!key) {
+            throw new Error('Key is required for set action');
+        }
+        if (!value) {
+            throw new Error('Value is required for set action');
+        }
+        this.configService.set(key, value);
+        this.logger.success(`Config set: ${key} = ${value}`);
+    }
+    async handleUnset(key) {
+        if (!key) {
+            throw new Error('Key is required for unset action');
+        }
+        this.configService.unset(key);
+        this.logger.success(`Config unset: ${key}`);
+    }
+    async handleList() {
+        const config = this.configService.list();
+        const entries = Object.entries(config);
+        if (entries.length === 0) {
+            this.logger.info('No configuration found');
+            return;
+        }
+        this.logger.info('Current configuration:');
+        for (const [key, value] of entries) {
+            this.logger.info(`  ${key} = ${value}`);
+        }
+    }
+    async handleInfo() {
+        const info = this.configService.getConfigInfo();
+        this.logger.info('Configuration file information:');
+        this.logger.info(`  Path: ${info.path}`);
+        this.logger.info(`  Exists: ${info.exists ? 'Yes' : 'No'}`);
+        if (info.exists) {
+            this.logger.info(`  Size: ${info.size} bytes`);
+            this.logger.info(`  Modified: ${info.modified?.toLocaleString()}`);
+        }
+        this.logger.info(`  Entries: ${info.entries}`);
+    }
+}
+exports.ConfigCommand = ConfigCommand;

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

@@ -0,0 +1,8 @@
+import { CommandOptionsValidator } from '../../types';
+import { ConfigCommandOptions } from './config.command';
+export declare class ConfigOptionValidator implements CommandOptionsValidator<ConfigCommandOptions> {
+    validate(options: ConfigCommandOptions): void;
+    private validateAction;
+    private validateKey;
+    private validateValue;
+}

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

@@ -0,0 +1,40 @@
+"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', 'info'];
+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' || action === 'info') {
+            return; // list and info don'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;

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

@@ -0,0 +1,4 @@
+import { MkSymlinkCommand, MkSymlinkCommandOptions } from './mksymlink.command';
+export declare class MkSymlinkCommandFactory {
+    static create(options: MkSymlinkCommandOptions): MkSymlinkCommand;
+}

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

@@ -0,0 +1,8 @@
+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;
+}

package/src/commands/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/src/commands/index.js

@@ -15,7 +15,7 @@ program
     .description('Create a symbolic link')
     .option('-s, --source <path>', 'Source path (defaults to current directory)')
     .option('-t, --target <path>', 'Target symlink path (auto-generated if not provided)')
-    .option('--type <type>', 'Symlink type for Windows: file, dir, junction (default: dir)', 'dir')
+    .option('--type <type>', 'Symlink type for Windows: file, dir, junction (default: junction)', 'junction')
     .option('-f, --force', 'Force overwrite existing symlink', false)
     .action(async (options) => {
     try {

package/src/index.d.ts

@@ -0,0 +1,11 @@
+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';

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

@@ -0,0 +1,44 @@
+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;
+}

package/src/services/config.service.js

@@ -0,0 +1,112 @@
+"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;

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

@@ -0,0 +1,10 @@
+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;
+}

package/src/services/platform-detector.js

@@ -0,0 +1,35 @@
+"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;

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

@@ -0,0 +1,11 @@
+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;
+}

package/src/services/symlink-error.js

@@ -0,0 +1,32 @@
+"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;

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

@@ -0,0 +1,12 @@
+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>;
+}

package/src/services/symlink-manager.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymlinkService = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const promises_1 = require("fs/promises");
+const symlink_error_1 = require("./symlink-error");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class SymlinkService {
+    logger;
+    osDetector;
+    constructor(logger, osDetector) {
+        this.logger = logger;
+        this.osDetector = osDetector;
+    }
+    async createSymlink(options) {
+        const { source, target, type = 'dir', force = false } = options;
+        try {
+            // this.logger.info(`Creating symlink: ${target} -> ${source}`);
+            if (await this.symlinkExists(target)) {
+                if (!force) {
+                    return {
+                        success: false,
+                        source,
+                        target,
+                        message: `Symlink already exists: ${target}`,
+                    };
+                }
+                this.logger.info(`Force mode enabled. Removing existing symlink: ${target}`);
+                await this.removeSymlink(target);
+            }
+            if (this.osDetector.isWindows()) {
+                await this.createWindowsSymlink(source, target, type);
+            }
+            else {
+                await this.createUnixSymlink(source, target);
+            }
+            // this.logger.success(`Symlink created successfully: ${target} -> ${source}`);
+            return {
+                success: true,
+                source,
+                target,
+                message: 'Symlink created successfully',
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to create symlink: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                success: false,
+                source,
+                target,
+                error: error instanceof Error ? error : new Error(String(error)),
+            };
+        }
+    }
+    async createWindowsSymlink(source, target, type) {
+        let flag;
+        switch (type) {
+            case 'junction':
+                flag = '/J';
+                break;
+            case 'file':
+                flag = '';
+                break;
+            case 'dir':
+            default:
+                flag = '/D';
+                break;
+        }
+        const command = flag
+            ? `mklink ${flag} "${target}" "${source}"`
+            : `mklink "${target}" "${source}"`;
+        this.logger.info(`Executing Windows command: ${command}`);
+        try {
+            const { stdout, stderr } = await execAsync(command, { shell: 'cmd.exe' });
+            if (stderr && !stderr.includes('Junction') && !stderr.includes('symbolic link')) {
+                throw new symlink_error_1.SymlinkError(stderr, 'WINDOWS_MKLINK_ERROR');
+            }
+            this.logger.info(`Windows mklink output: ${stdout}`);
+        }
+        catch (error) {
+            throw new symlink_error_1.SymlinkError(`Failed to create Windows symlink: ${error instanceof Error ? error.message : String(error)}`, 'WINDOWS_MKLINK_FAILED');
+        }
+    }
+    async createUnixSymlink(source, target) {
+        try {
+            await (0, promises_1.symlink)(source, target);
+            this.logger.info(`Unix symlink created: ln -s ${source} ${target}`);
+        }
+        catch (error) {
+            throw new symlink_error_1.SymlinkError(`Failed to create Unix symlink: ${error instanceof Error ? error.message : String(error)}`, 'UNIX_SYMLINK_FAILED');
+        }
+    }
+    async symlinkExists(path) {
+        try {
+            const stats = await (0, promises_1.lstat)(path);
+            return stats.isSymbolicLink();
+        }
+        catch {
+            return false;
+        }
+    }
+    async removeSymlink(path) {
+        try {
+            await (0, promises_1.access)(path);
+            await (0, promises_1.unlink)(path);
+            this.logger.info(`Symlink removed: ${path}`);
+        }
+        catch (error) {
+            throw new symlink_error_1.SymlinkError(`Failed to remove symlink: ${error instanceof Error ? error.message : String(error)}`, 'REMOVE_SYMLINK_FAILED');
+        }
+    }
+}
+exports.SymlinkService = SymlinkService;

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

@@ -0,0 +1,12 @@
+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>;
+}

package/src/services/symlink.service.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymlinkService = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const promises_1 = require("fs/promises");
+const symlink_error_1 = require("./symlink-error");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class SymlinkService {
+    logger;
+    osDetector;
+    constructor(logger, osDetector) {
+        this.logger = logger;
+        this.osDetector = osDetector;
+    }
+    async createSymlink(options) {
+        const { source, target, type = 'dir', force = false } = options;
+        try {
+            // this.logger.info(`Creating symlink: ${target} -> ${source}`);
+            if (await this.symlinkExists(target)) {
+                if (!force) {
+                    return {
+                        success: false,
+                        source,
+                        target,
+                        message: `Symlink already exists: ${target}`,
+                    };
+                }
+                this.logger.info(`Force mode enabled. Removing existing symlink: ${target}`);
+                await this.removeSymlink(target);
+            }
+            if (this.osDetector.isWindows()) {
+                await this.createWindowsSymlink(source, target, type);
+            }
+            else {
+                await this.createUnixSymlink(source, target);
+            }
+            // this.logger.success(`Symlink created successfully: ${target} -> ${source}`);
+            return {
+                success: true,
+                source,
+                target,
+                message: 'Symlink created successfully',
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to create symlink: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                success: false,
+                source,
+                target,
+                error: error instanceof Error ? error : new Error(String(error)),
+            };
+        }
+    }
+    async createWindowsSymlink(source, target, type) {
+        let flag;
+        switch (type) {
+            case 'junction':
+                flag = '/J';
+                break;
+            case 'file':
+                flag = '';
+                break;
+            case 'dir':
+            default:
+                flag = '/D';
+                break;
+        }
+        const command = flag
+            ? `mklink ${flag} "${target}" "${source}"`
+            : `mklink "${target}" "${source}"`;
+        this.logger.info(`Executing Windows command: ${command}`);
+        try {
+            const { stdout, stderr } = await execAsync(command, { shell: 'cmd.exe' });
+            if (stderr && !stderr.includes('Junction') && !stderr.includes('symbolic link')) {
+                throw new symlink_error_1.SymlinkError(stderr, 'WINDOWS_MKLINK_ERROR');
+            }
+            this.logger.info(`Windows mklink output: ${stdout}`);
+        }
+        catch (error) {
+            throw new symlink_error_1.SymlinkError(`Failed to create Windows symlink: ${error instanceof Error ? error.message : String(error)}`, 'WINDOWS_MKLINK_FAILED');
+        }
+    }
+    async createUnixSymlink(source, target) {
+        try {
+            await (0, promises_1.symlink)(source, target);
+            this.logger.info(`Unix symlink created: ln -s ${source} ${target}`);
+        }
+        catch (error) {
+            throw new symlink_error_1.SymlinkError(`Failed to create Unix symlink: ${error instanceof Error ? error.message : String(error)}`, 'UNIX_SYMLINK_FAILED');
+        }
+    }
+    async symlinkExists(path) {
+        try {
+            const stats = await (0, promises_1.lstat)(path);
+            return stats.isSymbolicLink();
+        }
+        catch {
+            return false;
+        }
+    }
+    async removeSymlink(path) {
+        try {
+            await (0, promises_1.access)(path);
+            await (0, promises_1.unlink)(path);
+            this.logger.info(`Symlink removed: ${path}`);
+        }
+        catch (error) {
+            throw new symlink_error_1.SymlinkError(`Failed to remove symlink: ${error instanceof Error ? error.message : String(error)}`, 'REMOVE_SYMLINK_FAILED');
+        }
+    }
+}
+exports.SymlinkService = SymlinkService;

package/src/types/index.d.ts

@@ -0,0 +1,39 @@
+export type CommandName = string;
+export interface CommandOptions {
+    [key: string]: unknown;
+}
+export interface Command<TOptions extends CommandOptions> {
+    execute(options: TOptions): Promise<void>;
+}
+export interface CommandError extends Error {
+    code?: string;
+}
+export interface CommandOptionsValidator<TOptions extends CommandOptions> {
+    validate(options: TOptions): void;
+}
+export type OSPlatform = 'darwin' | 'win32' | 'linux' | 'unknown';
+export type WindowsSymlinkType = 'file' | 'dir' | 'junction';
+export interface SymlinkOptions {
+    source: string;
+    target: string;
+    type?: WindowsSymlinkType;
+    force?: boolean;
+}
+export interface SymlinkResult {
+    success: boolean;
+    source: string;
+    target: string;
+    message?: string;
+    error?: Error;
+}
+export interface PlatformInformation {
+    getPlatform(): OSPlatform;
+    isWindows(): boolean;
+    isMacOS(): boolean;
+    isLinux(): boolean;
+}
+export interface SymlinkOperations {
+    createSymlink(options: SymlinkOptions): Promise<SymlinkResult>;
+    symlinkExists(path: string): Promise<boolean>;
+    removeSymlink(path: string): Promise<void>;
+}

package/src/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });