symlx 0.1.0

package/README.md

@@ -0,0 +1,63 @@
+# zlx
+
+Temporary CLI bin linker for local development.
+
+## What it does
+
+`zlx serve` reads the current project's `package.json` `bin` entries and symlinks them into:
+
+`~/.zlx/bin`
+
+While `zlx serve` is running, those commands can be used from anywhere (if `~/.zlx/bin` is on your `PATH`).
+
+When the process exits, it removes only the links it created.
+
+## Command framework and structure
+
+`zlx` uses:
+
+- `commander` for command orchestration and typed options.
+- `prompts` for interactive/TUI collision handling.
+
+Project layout:
+
+- `src/commands` command handlers
+- `src/services` bin/session/lifecycle services
+- `src/core` shared types/path helpers
+- `src/ui` terminal UI prompts/logging
+
+## Usage
+
+```bash
+npx zlx serve
+```
+
+or if installed globally:
+
+```bash
+zlx serve
+```
+
+### Serve options
+
+```bash
+zlx serve --collision prompt
+zlx serve --collision skip
+zlx serve --collision fail
+zlx serve --collision overwrite
+zlx serve --non-interactive
+zlx serve --bin-dir /custom/bin
+```
+
+If your shell does not already include `~/.zlx/bin`, add:
+
+```bash
+export PATH="$HOME/.zlx/bin:$PATH"
+```
+
+## Notes
+
+- Prompt mode lets you choose overwrite/skip/abort when a command name already exists.
+- In non-interactive sessions, prompt mode falls back to skip.
+- Stale links from dead sessions are cleaned on the next startup.
+- `kill -9` cannot cleanup instantly, but stale cleanup runs next time.

package/dist/cli.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+"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 });
+const commander_1 = require("commander");
+const serve_1 = require("./commands/serve");
+const log = __importStar(require("./ui/logger"));
+// Accepted values for --collision.
+const ALLOWED_COLLISIONS = new Set(["prompt", "skip", "fail", "overwrite"]);
+// Converts raw CLI input into a validated union type used by the serve command.
+function parseCollisionPolicy(value) {
+    if (!ALLOWED_COLLISIONS.has(value)) {
+        throw new Error(`invalid collision policy "${value}". expected: prompt|skip|fail|overwrite`);
+    }
+    return value;
+}
+async function main() {
+    // Commander orchestrates top-level commands/options and help output.
+    const program = new commander_1.Command();
+    program
+        .name("zlx")
+        .description("Temporary CLI bin linker with lifecycle cleanup")
+        .showHelpAfterError();
+    program
+        .command("serve")
+        .description("Link this project's package.json bins until zlx exits")
+        .option("--bin-dir <dir>", "target bin directory (default: ~/.zlx/bin)")
+        .option("--collision <policy>", "collision mode: prompt|skip|fail|overwrite", "prompt")
+        .option("--non-interactive", "disable interactive prompts", false)
+        .action(async (options) => {
+        // Delegate all runtime behavior to the command module.
+        await (0, serve_1.runServe)({
+            binDir: options.binDir,
+            collision: parseCollisionPolicy(options.collision),
+            nonInteractive: options.nonInteractive
+        });
+    });
+    await program.parseAsync(process.argv);
+}
+// Centralized fatal error boundary for command execution.
+main().catch((error) => {
+    log.error(String(error));
+    process.exit(1);
+});

package/dist/commands/serve.js

@@ -0,0 +1,103 @@
+"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.runServe = runServe;
+const paths_1 = require("../core/paths");
+const link_manager_1 = require("../services/link-manager");
+const lifecycle_1 = require("../services/lifecycle");
+const package_bins_1 = require("../services/package-bins");
+const session_store_1 = require("../services/session-store");
+const collision_prompt_1 = require("../ui/collision-prompt");
+const log = __importStar(require("../ui/logger"));
+// Prompts require an interactive terminal; scripts/CI should avoid prompt mode.
+function isInteractiveSession() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+// Main zlx behavior:
+// 1) resolve bins from package.json
+// 2) create links
+// 3) persist session
+// 4) keep process alive and cleanup on exit
+async function runServe(options) {
+    const cwd = process.cwd();
+    const paths = (0, paths_1.getZlxPaths)(options.binDir);
+    // Prepare runtime directories and recover stale sessions from previous abnormal exits.
+    (0, session_store_1.ensureZlxDirectories)(paths.binDir, paths.sessionDir);
+    (0, session_store_1.cleanupStaleSessions)(paths.sessionDir);
+    const bins = (0, package_bins_1.readBins)(cwd);
+    // Prompt policy only works when we can interact with a TTY.
+    const usePrompts = options.collision === "prompt" && !options.nonInteractive && isInteractiveSession();
+    if (options.collision === "prompt" && !usePrompts) {
+        log.warn("prompt collision mode requested but session is non-interactive; falling back to skip");
+    }
+    // Link creation returns both successful links and explicit skips.
+    const linkResult = await (0, link_manager_1.createLinks)({
+        bins,
+        binDir: paths.binDir,
+        policy: options.collision,
+        collisionResolver: usePrompts ? collision_prompt_1.promptCollisionDecision : undefined
+    });
+    if (linkResult.created.length === 0) {
+        throw new Error("no links were created");
+    }
+    // Session file is the source of truth for cleaning this exact run's links.
+    const sessionPath = (0, session_store_1.createSessionFilePath)(paths.sessionDir);
+    const sessionRecord = {
+        pid: process.pid,
+        cwd,
+        createdAt: new Date().toISOString(),
+        links: linkResult.created
+    };
+    (0, session_store_1.persistSession)(sessionPath, sessionRecord);
+    // Always cleanup linked commands when this process leaves.
+    (0, lifecycle_1.registerLifecycleCleanup)(() => {
+        (0, session_store_1.cleanupSession)(sessionPath, sessionRecord.links);
+    });
+    log.info(`linked ${linkResult.created.length} command(s) into ${paths.binDir}`);
+    for (const link of linkResult.created) {
+        log.info(`${link.name} -> ${link.target}`);
+    }
+    for (const skip of linkResult.skipped) {
+        log.warn(`skip "${skip.name}": ${skip.reason} (${skip.linkPath})`);
+    }
+    if (!(0, paths_1.pathContainsDir)(process.env.PATH, paths.binDir)) {
+        log.info(`add this to your shell config if needed:\nexport PATH="${paths.binDir}:$PATH"`);
+    }
+    log.info("running. press Ctrl+C to cleanup links.");
+    // Keep process alive indefinitely; lifecycle handlers handle termination and cleanup.
+    await new Promise(() => {
+        setInterval(() => undefined, 60_000);
+    });
+}

package/dist/core/paths.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZlxPaths = getZlxPaths;
+exports.pathContainsDir = pathContainsDir;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+// Central place for runtime paths so every command/service resolves locations consistently.
+function getZlxPaths(customBinDir) {
+    // zlx keeps mutable runtime state under the user's home directory.
+    const rootDir = node_path_1.default.join(node_os_1.default.homedir(), ".zlx");
+    // Commands are linked here unless the caller overrides with --bin-dir.
+    const binDir = customBinDir ? node_path_1.default.resolve(customBinDir) : node_path_1.default.join(rootDir, "bin");
+    // Session files live separately from bins and are used for stale cleanup.
+    const sessionDir = node_path_1.default.join(rootDir, "sessions");
+    return { rootDir, binDir, sessionDir };
+}
+// 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/core/types.js

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

package/dist/services/lifecycle.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLifecycleCleanup = registerLifecycleCleanup;
+// 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 registerLifecycleCleanup(cleanup) {
+    let cleaned = false;
+    const runCleanup = () => {
+        if (cleaned) {
+            return;
+        }
+        cleaned = true;
+        cleanup();
+    };
+    // 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(`[zlx] uncaught exception: ${String(error)}\n`);
+        runCleanup();
+        process.exit(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+        process.stderr.write(`[zlx] unhandled rejection: ${String(reason)}\n`);
+        runCleanup();
+        process.exit(1);
+    });
+}

package/dist/services/link-manager.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLinks = createLinks;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// lstat wrapper that treats missing files as "not found" but rethrows real IO errors.
+function tryLstat(filePath) {
+    try {
+        return node_fs_1.default.lstatSync(filePath);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+// Reads an existing command path and resolves the symlink target when possible.
+function inspectExistingNode(linkPath) {
+    const stats = tryLstat(linkPath);
+    if (!stats) {
+        return undefined;
+    }
+    if (!stats.isSymbolicLink()) {
+        return { stats };
+    }
+    try {
+        const rawTarget = node_fs_1.default.readlinkSync(linkPath);
+        const existingTarget = node_path_1.default.resolve(node_path_1.default.dirname(linkPath), rawTarget);
+        return { stats, existingTarget };
+    }
+    catch {
+        return { stats };
+    }
+}
+// Removes an existing file/symlink to make room for a new command link.
+// We do not delete directories to avoid destructive behavior.
+function removeExistingNode(linkPath, node) {
+    if (node.stats.isDirectory() && !node.stats.isSymbolicLink()) {
+        throw new Error(`cannot overwrite directory at ${linkPath}`);
+    }
+    node_fs_1.default.unlinkSync(linkPath);
+}
+// Normalizes filesystem state into a user-facing collision descriptor.
+function toConflict(name, linkPath, target, node) {
+    if (node.stats.isSymbolicLink()) {
+        return {
+            name,
+            linkPath,
+            target,
+            reason: node.existingTarget
+                ? `already linked to ${node.existingTarget}`
+                : "already exists as symlink",
+            existingTarget: node.existingTarget,
+            isSymlink: true
+        };
+    }
+    return {
+        name,
+        linkPath,
+        target,
+        reason: "already exists as a file",
+        isSymlink: false
+    };
+}
+// Creates symlinks for all project bins according to the selected collision strategy.
+// This function is pure with regard to policy: caller decides interactive vs non-interactive.
+async function createLinks(params) {
+    const { bins, binDir, policy, collisionResolver } = params;
+    const created = [];
+    const skipped = [];
+    for (const [name, target] of bins.entries()) {
+        const linkPath = node_path_1.default.join(binDir, name);
+        const existingNode = inspectExistingNode(linkPath);
+        if (existingNode) {
+            const conflict = toConflict(name, linkPath, target, existingNode);
+            // Reusing the exact same link is always a no-op.
+            if (conflict.existingTarget && node_path_1.default.resolve(conflict.existingTarget) === node_path_1.default.resolve(target)) {
+                skipped.push({ name, linkPath, reason: "already linked to requested target" });
+                continue;
+            }
+            let decision;
+            if (policy === "skip") {
+                decision = "skip";
+            }
+            else if (policy === "overwrite") {
+                decision = "overwrite";
+            }
+            else if (policy === "fail") {
+                throw new Error(`command "${name}" conflicts at ${linkPath}: ${conflict.reason}`);
+            }
+            else {
+                decision = collisionResolver ? await collisionResolver(conflict) : "skip";
+            }
+            if (decision === "abort") {
+                throw new Error(`aborted on collision for command "${name}"`);
+            }
+            if (decision === "skip") {
+                skipped.push({ name, linkPath, reason: conflict.reason });
+                continue;
+            }
+            removeExistingNode(linkPath, existingNode);
+        }
+        node_fs_1.default.symlinkSync(target, linkPath);
+        created.push({ name, linkPath, target });
+    }
+    return { created, skipped };
+}

package/dist/services/package-bins.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readBins = readBins;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// 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) {
+        throw new Error("package.json is missing `name`, needed when `bin` is a string");
+    }
+    if (packageName.startsWith("@")) {
+        const parts = packageName.split("/");
+        if (parts.length !== 2 || !parts[1]) {
+            throw new Error(`invalid package name: ${packageName}`);
+        }
+        return parts[1];
+    }
+    return packageName;
+}
+function readJsonFile(filePath) {
+    const raw = node_fs_1.default.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+}
+// Loads and validates all bin entries for the current project.
+// Returned map is command name => absolute target file path.
+function readBins(cwd) {
+    const packageJsonPath = node_path_1.default.join(cwd, "package.json");
+    if (!node_fs_1.default.existsSync(packageJsonPath)) {
+        throw new Error(`missing package.json in ${cwd}`);
+    }
+    const packageJson = readJsonFile(packageJsonPath);
+    if (!packageJson.bin) {
+        throw new Error("package.json has no `bin` field");
+    }
+    const bins = new Map();
+    if (typeof packageJson.bin === "string") {
+        bins.set(inferBinName(packageJson.name), node_path_1.default.resolve(cwd, packageJson.bin));
+    }
+    else {
+        for (const [name, relTarget] of Object.entries(packageJson.bin)) {
+            bins.set(name, node_path_1.default.resolve(cwd, relTarget));
+        }
+    }
+    if (bins.size === 0) {
+        throw new Error("no bin entries found");
+    }
+    // Fail fast if package.json points to non-existing executables.
+    for (const [name, target] of bins.entries()) {
+        if (!node_fs_1.default.existsSync(target)) {
+            throw new Error(`bin target for "${name}" does not exist: ${target}`);
+        }
+    }
+    return bins;
+}

package/dist/services/session-store.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureZlxDirectories = ensureZlxDirectories;
+exports.cleanupStaleSessions = cleanupStaleSessions;
+exports.persistSession = persistSession;
+exports.createSessionFilePath = createSessionFilePath;
+exports.cleanupSession = cleanupSession;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// Lightweight JSON reader used for session metadata files.
+function readJsonFile(filePath) {
+    const raw = node_fs_1.default.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+}
+// Checks whether a PID from a previous session is still alive.
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        return code !== "ESRCH";
+    }
+}
+// Session files are best-effort state; deletion failure should not fail the command.
+function deleteSessionFile(filePath) {
+    try {
+        node_fs_1.default.unlinkSync(filePath);
+    }
+    catch {
+        // Best-effort cleanup.
+    }
+}
+// Invalid/corrupted session files are ignored and later removed.
+function loadSession(filePath) {
+    try {
+        return readJsonFile(filePath);
+    }
+    catch {
+        return undefined;
+    }
+}
+// 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) {
+    for (const link of links) {
+        try {
+            const stats = node_fs_1.default.lstatSync(link.linkPath);
+            if (!stats.isSymbolicLink()) {
+                continue;
+            }
+            const linkedTo = node_fs_1.default.readlinkSync(link.linkPath);
+            const absoluteLinkedTo = node_path_1.default.resolve(node_path_1.default.dirname(link.linkPath), linkedTo);
+            if (absoluteLinkedTo === node_path_1.default.resolve(link.target)) {
+                node_fs_1.default.unlinkSync(link.linkPath);
+            }
+        }
+        catch {
+            // Best-effort cleanup.
+        }
+    }
+}
+// Ensures runtime directories exist before linking/saving sessions.
+function ensureZlxDirectories(binDir, sessionDir) {
+    node_fs_1.default.mkdirSync(binDir, { recursive: true });
+    node_fs_1.default.mkdirSync(sessionDir, { recursive: true });
+}
+// Reaps stale sessions left behind by crashes/kill -9 and removes their symlinks.
+function cleanupStaleSessions(sessionDir) {
+    if (!node_fs_1.default.existsSync(sessionDir)) {
+        return;
+    }
+    for (const entry of node_fs_1.default.readdirSync(sessionDir)) {
+        if (!entry.endsWith(".json")) {
+            continue;
+        }
+        const filePath = node_path_1.default.join(sessionDir, entry);
+        const record = loadSession(filePath);
+        if (!record) {
+            deleteSessionFile(filePath);
+            continue;
+        }
+        if (!isProcessAlive(record.pid)) {
+            cleanupLinks(record.links);
+            deleteSessionFile(filePath);
+        }
+    }
+}
+// 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) {
+    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);
+    deleteSessionFile(sessionPath);
+}

package/dist/ui/collision-prompt.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptCollisionDecision = promptCollisionDecision;
+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) {
+    const response = await (0, prompts_1.default)({
+        type: "select",
+        name: "decision",
+        message: `command "${conflict.name}" already exists`,
+        choices: [
+            {
+                title: "Overwrite existing command",
+                value: "overwrite",
+                description: `Replace ${conflict.linkPath}`
+            },
+            {
+                title: "Skip this command",
+                value: "skip",
+                description: conflict.reason
+            },
+            {
+                title: "Abort",
+                value: "abort",
+                description: "Stop serve without linking remaining commands"
+            }
+        ],
+        initial: 1
+    }, {
+        onCancel: () => false
+    });
+    if (!response.decision) {
+        return "abort";
+    }
+    return response.decision;
+}

package/dist/ui/logger.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.info = info;
+exports.warn = warn;
+exports.error = error;
+const PREFIX = "[zlx]";
+// Thin logging wrappers keep formatting centralized and easy to swap later.
+function info(message) {
+    process.stdout.write(`${PREFIX} ${message}\n`);
+}
+function warn(message) {
+    process.stderr.write(`${PREFIX} ${message}\n`);
+}
+function error(message) {
+    process.stderr.write(`${PREFIX} ${message}\n`);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "symlx",
+  "version": "0.1.0",
+  "description": "Temporary local CLI bin linker",
+  "license": "MIT",
+  "bin": {
+    "symlx": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "cli",
+    "bin",
+    "dev"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.9.0"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "prompts": "^2.4.2"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && chmod +x dist/cli.js",
+    "check": "tsc -p tsconfig.json --noEmit"
+  }
+}