symlx 0.1.3 → 0.1.5

package/dist/lib/serve-runtime.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServeSession = startServeSession;
+const node_path_1 = __importDefault(require("node:path"));
+function resolveCollisionSummary(options, dependencies) {
+    if (options.collision !== 'prompt') {
+        return {
+            requested: options.collision,
+            effective: options.collision,
+        };
+    }
+    const shouldFallbackToSkip = options.nonInteractive || !dependencies.isInteractiveSession();
+    if (!shouldFallbackToSkip) {
+        return {
+            requested: options.collision,
+            effective: 'prompt',
+        };
+    }
+    return {
+        requested: options.collision,
+        effective: 'skip',
+        warning: 'prompt collision mode requested but session is non-interactive; falling back to skip (use --collision overwrite|fail to avoid skips)',
+    };
+}
+function formatSkippedLinks(skippedLinks) {
+    const visibleSkippedLinks = skippedLinks.slice(0, 5);
+    const details = visibleSkippedLinks
+        .map((skip) => `- ${skip.name}: ${skip.reason}`)
+        .join('\n');
+    const remainingCount = skippedLinks.length - visibleSkippedLinks.length;
+    const remaining = remainingCount > 0 ? `\n- ...and ${remainingCount} more` : '';
+    return `${details}${remaining}`;
+}
+function assertLinksCreated(linkResult) {
+    if (linkResult.created.length > 0) {
+        return;
+    }
+    if (linkResult.skipped.length === 0) {
+        throw new Error('no links were created');
+    }
+    throw new Error([
+        'no links were created because all candidate commands were skipped.',
+        formatSkippedLinks(linkResult.skipped),
+        'use --collision overwrite or --collision fail for stricter behavior.',
+    ].join('\n'));
+}
+async function startServeSession(params) {
+    const { options, dependencies, promptCollisionResolver } = params;
+    const currentWorkingDirectory = dependencies.resolveWorkingDirectory();
+    const homeDirectory = dependencies.resolveHomeDirectory();
+    const sessionDirectory = node_path_1.default.join(homeDirectory, '.symlx', 'sessions');
+    const collision = resolveCollisionSummary(options, dependencies);
+    dependencies.cleanupStaleSessions(sessionDirectory);
+    dependencies.ensureDirectories(options.binDir, sessionDirectory);
+    dependencies.assertValidBinTargets(options.bin);
+    const linkResult = await dependencies.createLinks({
+        bins: options.bin,
+        binDir: options.binDir,
+        policy: collision.effective,
+        collisionResolver: collision.effective === 'prompt' ? promptCollisionResolver : undefined,
+    });
+    assertLinksCreated(linkResult);
+    const sessionPath = dependencies.createSessionFilePath(sessionDirectory);
+    const sessionRecord = {
+        pid: dependencies.resolveProcessId(),
+        cwd: currentWorkingDirectory,
+        createdAt: dependencies.resolveTimestamp(),
+        links: linkResult.created,
+    };
+    dependencies.persistSession(sessionPath, sessionRecord);
+    dependencies.registerLifecycleCleanup(() => {
+        dependencies.cleanupSession(sessionPath, sessionRecord.links);
+    });
+    return {
+        collision,
+        waitUntilStopped: dependencies.waitUntilStopped,
+    };
+}

package/dist/{services → lib}/session-store.js

@@ -36,15 +36,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupLinks = cleanupLinks;
 exports.ensureSymlxDirectories = ensureSymlxDirectories;
 exports.cleanupStaleSessions = cleanupStaleSessions;
+exports.generateSessionFilePath = generateSessionFilePath;
+exports.generateSessionRecord = generateSessionRecord;
 exports.persistSession = persistSession;
-exports.createSessionFilePath = createSessionFilePath;
-exports.cleanupSession = cleanupSession;
+exports.registerLifecycleSessionCleanup = registerLifecycleSessionCleanup;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const log = __importStar(require("../ui/logger"));
-const utils_1 = require("../lib/utils");
+const utils_1 = require("./utils");
 // Checks whether a PID from a previous session is still alive.
 function isProcessAlive(pid) {
     // PIDs are always positive integer typically less the 2^15
@@ -63,15 +65,6 @@ function isProcessAlive(pid) {
         return code !== 'ESRCH';
     }
 }
-// Session files are best-effort state; deletion failure should not fail the command.
-function deleteFile(filePath) {
-    try {
-        node_fs_1.default.unlinkSync(filePath);
-    }
-    catch {
-        // Best-effort cleanup.
-    }
-}
 // Removes only symlinks that still point to the exact targets we created.
 // This avoids deleting user-managed commands with the same name.
 function cleanupLinks(links) {
@@ -92,7 +85,6 @@ function cleanupLinks(links) {
         }
     }
 }
-// -----------------------------------------------------------
 // Ensures runtime directories exist before linking/saving sessions.
 function ensureSymlxDirectories(binDir, sessionDir) {
     node_fs_1.default.mkdirSync(binDir, { recursive: true });
@@ -110,19 +102,19 @@ function cleanupStaleSessions(sessionDir) {
         const filePath = node_path_1.default.join(sessionDir, entry);
         // Delete any files that are not .json, session files can only be JSON
         if (!entry.endsWith('.json')) {
-            deleteFile(filePath);
+            (0, utils_1.deleteFile)(filePath);
             continue;
         }
         // If the expected file structure has been corrupted, delete the file
         const record = (0, utils_1.loadJSONFile)(filePath);
         if (!record) {
-            deleteFile(filePath);
+            (0, utils_1.deleteFile)(filePath);
             continue;
         }
         // If process is dead, unlink the command from the bin and delete the session file
         if (!isProcessAlive(record.pid)) {
             cleanupLinks(record.links);
-            deleteFile(filePath);
+            (0, utils_1.deleteFile)(filePath);
             cleanUpCount++;
         }
     }
@@ -130,17 +122,54 @@ function cleanupStaleSessions(sessionDir) {
         log.info(`cleaned up ${cleanUpCount} expired session${cleanUpCount > 1 ? 's' : ''}`);
     }
 }
-// Persists currently linked commands so future runs can clean stale state.
-function persistSession(sessionPath, record) {
-    node_fs_1.default.writeFileSync(sessionPath, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
-}
 // Produces unique session file names to avoid collisions across concurrent runs.
-function createSessionFilePath(sessionDir) {
+function generateSessionFilePath(sessionDir) {
     const unique = `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
     return node_path_1.default.join(sessionDir, `${unique}.json`);
 }
-// Cleanup for the active process/session.
-function cleanupSession(sessionPath, links) {
-    cleanupLinks(links);
-    deleteFile(sessionPath);
+function generateSessionRecord(cwd, links) {
+    return {
+        pid: process.pid,
+        cwd,
+        createdAt: new Date().toISOString(),
+        links,
+    };
+}
+// Persists currently linked commands so future runs can clean stale state.
+function persistSession(sessionPath, record) {
+    node_fs_1.default.writeFileSync(sessionPath, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+}
+// Registers robust process-exit handling so linked commands are removed reliably.
+// Cleanup is idempotent and can be triggered by normal exit, signals, or fatal errors.
+function registerLifecycleSessionCleanup(sessionPath, links) {
+    let cleaned = false;
+    const runCleanup = () => {
+        if (cleaned) {
+            return;
+        }
+        cleaned = true;
+        cleanupLinks(links);
+        (0, utils_1.deleteFile)(sessionPath);
+    };
+    // Normal termination path.
+    process.on('exit', runCleanup);
+    const onSignal = () => {
+        runCleanup();
+        process.exit(0);
+    };
+    // Common interactive stop signals.
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
+    process.on('SIGHUP', onSignal);
+    // Fatal process events still attempt cleanup before exiting with failure.
+    process.on('uncaughtException', (error) => {
+        process.stderr.write(`[symlx] uncaught exception: ${String(error)}\n`);
+        runCleanup();
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (reason) => {
+        process.stderr.write(`[symlx] unhandled rejection: ${String(reason)}\n`);
+        runCleanup();
+        process.exit(1);
+    });
 }

package/dist/lib/utils.js

@@ -5,6 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadJSONFile = loadJSONFile;
 exports.loadConfigFileOptions = loadConfigFileOptions;
+exports.loadPackageJSONOptions = loadPackageJSONOptions;
+exports.deleteFile = deleteFile;
+exports.pathContainsDir = pathContainsDir;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 // Invalid/corrupted JSON files are ignored.
@@ -17,9 +20,109 @@ function loadJSONFile(filePath) {
         return undefined;
     }
 }
-function loadConfigFileOptions() {
-    const cwd = process.cwd();
+function formatReadError(error) {
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
+    return String(error);
+}
+function readJSONFileWithIssue(filePath, label) {
+    try {
+        const raw = node_fs_1.default.readFileSync(filePath, 'utf8');
+        return { data: JSON.parse(raw) };
+    }
+    catch (error) {
+        return {
+            issue: `invalid ${label} at ${filePath}: ${formatReadError(error)}`,
+        };
+    }
+}
+function loadConfigFileOptions(cwd) {
     const configPath = node_path_1.default.join(cwd, 'symlx.config.json');
-    const configFileOptions = loadJSONFile(configPath);
-    return configFileOptions;
+    if (!node_fs_1.default.existsSync(configPath)) {
+        return {};
+    }
+    const result = readJSONFileWithIssue(configPath, 'symlx.config.json');
+    // throw error if there were file reading issues
+    if (result.issue) {
+        throw new Error(result.issue);
+    }
+    return { options: result.data };
+}
+// npm allows `bin` as a string; in that form the command name defaults to package name
+// (without scope for scoped packages).
+function inferBinName(packageName) {
+    if (!packageName) {
+        return undefined;
+    }
+    if (packageName.startsWith('@')) {
+        const parts = packageName.split('/');
+        if (parts.length !== 2 || !parts[1]) {
+            return undefined;
+        }
+        return parts[1];
+    }
+    return packageName;
+}
+// Loads and validates all bin entries for the current project.
+// Returned map is command name => absolute target file path.
+function loadPackageJSONOptions(cwd) {
+    const packageJsonPath = node_path_1.default.join(cwd, 'package.json');
+    if (!node_fs_1.default.existsSync(packageJsonPath)) {
+        return {
+            bin: {},
+            issues: [`package.json not found at ${packageJsonPath}`],
+        };
+    }
+    const parsedPackageJSON = readJSONFileWithIssue(packageJsonPath, 'package.json');
+    if (parsedPackageJSON.issue) {
+        return {
+            bin: {},
+            issues: [parsedPackageJSON.issue],
+        };
+    }
+    const packageJson = parsedPackageJSON.data;
+    if (!packageJson || !packageJson.bin) {
+        return {
+            bin: {},
+            issues: [],
+        };
+    }
+    const bin = {};
+    const issues = [];
+    if (typeof packageJson.bin === 'string') {
+        const inferredBinName = inferBinName(packageJson.name);
+        if (inferredBinName) {
+            bin[inferredBinName] = packageJson.bin;
+        }
+        else {
+            issues.push('bin field is a string, but could not infer name, set a valid package.json "name"');
+        }
+    }
+    else {
+        for (const [name, relTarget] of Object.entries(packageJson.bin)) {
+            bin[name] = relTarget;
+        }
+    }
+    return { bin, issues };
+}
+// Session files are best-effort state; deletion failure should not fail the command.
+function deleteFile(filePath) {
+    try {
+        node_fs_1.default.unlinkSync(filePath);
+    }
+    catch {
+        // Best-effort cleanup.
+    }
+}
+// Checks if PATH already contains a directory so we can avoid noisy setup hints.
+function pathContainsDir(currentPath, targetDir) {
+    if (!currentPath) {
+        return false;
+    }
+    const resolvedTarget = node_path_1.default.resolve(targetDir);
+    const parts = currentPath
+        .split(node_path_1.default.delimiter)
+        .map((item) => node_path_1.default.resolve(item));
+    return parts.includes(resolvedTarget);
 }

package/dist/lib/{validate.js → validator.js}

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateInlineOptions = validateInlineOptions;
+exports.validatePackageJSONOptions = validatePackageJSONOptions;
 exports.validateConfigFileOptions = validateConfigFileOptions;
+exports.validateInlineOptions = validateInlineOptions;
 const schema_1 = require("./schema");
 function formatIssues(error) {
     const details = error.issues
@@ -12,13 +13,15 @@ function formatIssues(error) {
         .join('; ');
     return details || 'invalid input';
 }
-function validateInlineOptions(schema, input, label = 'input') {
-    const result = schema.safeParse(input || {});
+function validatePackageJSONOptions(input) {
+    const result = schema_1.packageJSONOptionsSchema.safeParse(input || {});
     if (!result.success) {
-        throw new Error(`invalid ${label}: ${formatIssues(result.error)}`);
+        return { bin: {}, issues: result.error.issues.map((i) => i.message) };
     }
-    return result.data;
+    return { ...result.data, issues: [] };
 }
+// it's better ux/dx to throw if there's an error in the config file
+// provided it's available than falling back to defaults and leaving the user guessing
 function validateConfigFileOptions(input, label = 'input') {
     const result = schema_1.configFileOptionsSchema.safeParse(input || {});
     if (!result.success) {
@@ -26,3 +29,10 @@ function validateConfigFileOptions(input, label = 'input') {
     }
     return result.data;
 }
+function validateInlineOptions(schema, input, label = 'input') {
+    const result = schema.safeParse(input || {});
+    if (!result.success) {
+        throw new Error(`invalid ${label}: ${formatIssues(result.error)}`);
+    }
+    return result.data;
+}

package/dist/options.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binOption = exports.nonInteractiveOption = exports.binResolutionStrategyOption = exports.collisionOption = exports.binDirOption = void 0;
+function collectBinEntry(value, previous = []) {
+    previous.push(value);
+    return previous;
+}
+const binDirOption = [
+    '--bin-dir <dir>',
+    'target bin directory (default: ~/.symlx/bin)',
+];
+exports.binDirOption = binDirOption;
+const collisionOption = [
+    '--collision <policy>',
+    'collision mode: prompt|skip|fail|overwrite',
+    'prompt',
+];
+exports.collisionOption = collisionOption;
+const binResolutionStrategyOption = [
+    '--bin-resolution-strategy <strategy>',
+    'bin precedence strategy: replace|merge',
+    'replace',
+];
+exports.binResolutionStrategyOption = binResolutionStrategyOption;
+const nonInteractiveOption = [
+    '--non-interactive',
+    'disable interactive prompts',
+    false,
+];
+exports.nonInteractiveOption = nonInteractiveOption;
+const binOption = [
+    '--bin <name=path>',
+    'custom bin mapping (repeatable), e.g. --bin my-cli=dist/cli.js',
+    collectBinEntry,
+    [],
+];
+exports.binOption = binOption;

package/dist/postinstall.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const PREFIX = '[symlx]';
+const START = '# >>> symlx path >>>';
+const END = '# <<< symlx path <<<';
+const BIN_PATH = '$HOME/.symlx/bin';
+const PROFILE_BASENAMES = ['.zprofile', '.zshrc', '.bashrc'];
+function info(message) {
+    process.stdout.write(`${PREFIX} ${message}\n`);
+}
+function warn(message) {
+    process.stderr.write(`${PREFIX} ${message}\n`);
+}
+function printManualPathSetupGuidance() {
+    if (process.platform === 'win32') {
+        info('manual setup (PowerShell):');
+        info('[Environment]::SetEnvironmentVariable("Path", "$env:USERPROFILE\\\\.symlx\\\\bin;$env:Path", "User")');
+        info('then open a new terminal');
+        return;
+    }
+    info('manual setup: add this to ~/.zshrc, ~/.zprofile, or ~/.bashrc');
+    info(START);
+    info('if [[ ":$PATH:" != *":$HOME/.symlx/bin:"* ]]; then');
+    info('  export PATH="$HOME/.symlx/bin:$PATH"');
+    info('fi');
+    info(END);
+    info('then run: source ~/.zshrc (or your active shell profile)');
+}
+function resolveProfilePaths(homeDir) {
+    return PROFILE_BASENAMES.map((basename) => node_path_1.default.join(homeDir, basename));
+}
+function toHomeRelativePath(filePath, homeDir) {
+    if (filePath.startsWith(`${homeDir}${node_path_1.default.sep}`)) {
+        return `~/${node_path_1.default.relative(homeDir, filePath)}`;
+    }
+    return filePath;
+}
+function getPreferredSourcePath(updatedPaths) {
+    const shell = process.env.SHELL ?? '';
+    const preferredBasename = shell.includes('zsh')
+        ? '.zshrc'
+        : shell.includes('bash')
+            ? '.bashrc'
+            : undefined;
+    if (!preferredBasename) {
+        return updatedPaths[0];
+    }
+    return (updatedPaths.find((filePath) => node_path_1.default.basename(filePath) === preferredBasename) ??
+        updatedPaths[0]);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function buildPathBlock() {
+    return [
+        START,
+        `if [[ ":$PATH:" != *":${BIN_PATH}:"* ]]; then`,
+        `  export PATH="${BIN_PATH}:$PATH"`,
+        'fi',
+        END,
+    ].join('\n');
+}
+function ensureTrailingNewline(value) {
+    return value.endsWith('\n') ? value : `${value}\n`;
+}
+function upsertProfileBlock(filePath, block) {
+    const exists = node_fs_1.default.existsSync(filePath);
+    const current = exists ? node_fs_1.default.readFileSync(filePath, 'utf8') : '';
+    const normalizedCurrent = current.replace(/\r\n/g, '\n');
+    const markerPattern = new RegExp(`${escapeRegExp(START)}[\\s\\S]*?${escapeRegExp(END)}\\n?`, 'm');
+    let next;
+    if (markerPattern.test(normalizedCurrent)) {
+        next = normalizedCurrent.replace(markerPattern, `${block}\n`);
+    }
+    else if (normalizedCurrent.trim().length === 0) {
+        next = `${block}\n`;
+    }
+    else {
+        next = `${ensureTrailingNewline(normalizedCurrent)}\n${block}\n`;
+    }
+    if (next === normalizedCurrent) {
+        return false;
+    }
+    node_fs_1.default.writeFileSync(filePath, next, 'utf8');
+    return true;
+}
+function run() {
+    if (process.env.SYMLX_SKIP_PATH_SETUP === '1') {
+        info('skipping PATH setup because SYMLX_SKIP_PATH_SETUP=1');
+        printManualPathSetupGuidance();
+        return;
+    }
+    if (process.platform === 'win32') {
+        info('skipping shell profile PATH setup on Windows');
+        printManualPathSetupGuidance();
+        return;
+    }
+    const homeDir = node_os_1.default.homedir();
+    if (!homeDir) {
+        warn('could not resolve home directory; skipping PATH setup');
+        printManualPathSetupGuidance();
+        return;
+    }
+    const block = buildPathBlock();
+    const profilePaths = resolveProfilePaths(homeDir);
+    const existingPaths = profilePaths.filter((filePath) => node_fs_1.default.existsSync(filePath));
+    const targets = existingPaths.length > 0 ? existingPaths : [profilePaths[0]];
+    const updated = [];
+    for (const target of targets) {
+        try {
+            const changed = upsertProfileBlock(target, block);
+            if (changed) {
+                updated.push(target);
+            }
+        }
+        catch (error) {
+            warn(`could not update ${target}: ${String(error)}`);
+        }
+    }
+    if (updated.length > 0) {
+        info(`added ${BIN_PATH} to PATH in:`);
+        for (const target of updated) {
+            info(`- ${target}`);
+        }
+        const preferredSourcePath = getPreferredSourcePath(updated);
+        if (preferredSourcePath) {
+            const sourceTarget = toHomeRelativePath(preferredSourcePath, homeDir);
+            info(`run now: source ${sourceTarget}`);
+        }
+        info('or open a new shell to apply immediately');
+    }
+    else {
+        info(`PATH setup already present (${BIN_PATH})`);
+    }
+}
+run();

package/dist/preinstall.js

@@ -0,0 +1,10 @@
+"use strict";
+const PREFIX = '[symlx]';
+function info(message) {
+    process.stdout.write(`${PREFIX} ${message}\n`);
+}
+function run() {
+    info('notice: install will update your shell profile PATH with $HOME/.symlx/bin');
+    info('set SYMLX_SKIP_PATH_SETUP=1 to skip automatic PATH setup');
+}
+run();

package/dist/ui/{collision-prompt.js → prompts.js}

@@ -3,11 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptCollisionDecision = promptCollisionDecision;
+exports.promptCollisionResolver = promptCollisionResolver;
 const prompts_1 = __importDefault(require("prompts"));
 // Interactive collision resolver for --collision prompt.
 // Returning "abort" bubbles up as an error to stop the current serve run.
-async function promptCollisionDecision(conflict) {
+async function promptCollisionResolver(conflict) {
     const response = await (0, prompts_1.default)({
         type: 'select',
         name: 'decision',

package/dist/ui/serve-output.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printLinkOutcome = printLinkOutcome;
+exports.printPathHintIfNeeded = printPathHintIfNeeded;
+const utils_1 = require("../lib/utils");
+const log = __importStar(require("./logger"));
+function printLinkOutcome(binDir, linkResult) {
+    const createdLinks = linkResult.created;
+    log.info(`linked ${createdLinks.length} command${createdLinks.length > 1 ? 's' : ''} into ${binDir}`);
+    for (const link of createdLinks) {
+        log.info(`${link.name} -> ${link.target}`);
+    }
+    for (const skip of linkResult.skipped) {
+        log.warn(`skip "${skip.name}": ${skip.reason} (${skip.linkPath})`);
+    }
+}
+function printPathHintIfNeeded(binDir, currentPath) {
+    if ((0, utils_1.pathContainsDir)(currentPath, binDir)) {
+        return;
+    }
+    log.info(`add this to your shell config if needed:\nexport PATH="${binDir}:$PATH"`);
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "symlx",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Temporary local CLI bin linker",
   "license": "MIT",
   "bin": {
-    "symlx": "dist/clii.js",
-    "cx": "dist/clii.js"
+    "symlx": "dist/cli.js",
+    "cx": "dist/cli.js"
   },
   "files": [
     "dist",
@@ -31,6 +31,10 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && chmod +x dist/cli.js",
-    "check": "tsc -p tsconfig.json --noEmit"
+    "watch": "tsc -p tsconfig.json --watch --preserveWatchOutput",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "pnpm run build && tsc -p tsconfig.test.json && node --test .tmp-tests/test/**/*.test.js",
+    "preinstall": "node dist/preinstall.js",
+    "postinstall": "node dist/postinstall.js"
   }
 }