@tolinax/ayoune-cli 2026.3.1 → 2026.4.0

package/lib/api/searchClient.js

@@ -0,0 +1,119 @@
+import { api } from "./apiClient.js";
+import { config } from "../helpers/config.js";
+import { secureStorage } from "../helpers/secureStorage.js";
+function getToken() {
+    return secureStorage.getItem("token") || process.env.AYOUNE_TOKEN || "";
+}
+function getSearchBaseURL() {
+    return config.searchUrl;
+}
+export async function searchModel(collection, params) {
+    const response = await api({
+        baseURL: getSearchBaseURL(),
+        method: "get",
+        url: `/${collection}`,
+        params,
+        headers: {
+            Authorization: `Bearer ${getToken()}`,
+        },
+    });
+    return response.data;
+}
+export async function searchOne(collection, params) {
+    const response = await api({
+        baseURL: getSearchBaseURL(),
+        method: "get",
+        url: `/${collection}/one`,
+        params,
+        headers: {
+            Authorization: `Bearer ${getToken()}`,
+        },
+    });
+    return response.data;
+}
+export async function searchGlobal(query, limit = 25, callbacks = {}) {
+    const results = [];
+    const response = await api({
+        baseURL: getSearchBaseURL(),
+        method: "get",
+        url: "/",
+        params: { q: query, limit },
+        headers: {
+            Authorization: `Bearer ${getToken()}`,
+            Accept: "text/event-stream",
+        },
+        responseType: "stream",
+    });
+    return new Promise((resolve, reject) => {
+        let buffer = "";
+        let currentCollection = "";
+        let currentEntries = [];
+        const stream = response.data;
+        stream.on("data", (chunk) => {
+            var _a, _b, _c;
+            buffer += chunk.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (line.startsWith("event: ")) {
+                    const event = line.slice(7).trim();
+                    if (event === "model_done" && currentCollection) {
+                        const result = {
+                            collection: currentCollection,
+                            entries: currentEntries,
+                            total: currentEntries.length,
+                        };
+                        results.push(result);
+                        (_a = callbacks.onResult) === null || _a === void 0 ? void 0 : _a.call(callbacks, result);
+                        currentCollection = "";
+                        currentEntries = [];
+                    }
+                    else if (event === "error") {
+                        // Error data comes in the next data: line
+                    }
+                    else if (event === "done") {
+                        (_b = callbacks.onDone) === null || _b === void 0 ? void 0 : _b.call(callbacks);
+                    }
+                }
+                else if (line.startsWith("data: ")) {
+                    const dataStr = line.slice(6).trim();
+                    try {
+                        const data = JSON.parse(dataStr);
+                        if (data.model) {
+                            currentCollection = data.model;
+                        }
+                        else if (data.entry) {
+                            currentEntries.push(data.entry);
+                        }
+                        else if (data.error) {
+                            (_c = callbacks.onError) === null || _c === void 0 ? void 0 : _c.call(callbacks, data.error);
+                        }
+                    }
+                    catch (_d) {
+                        // Non-JSON data line, skip
+                    }
+                }
+            }
+        });
+        stream.on("end", () => {
+            var _a, _b;
+            // Flush remaining buffer
+            if (currentCollection && currentEntries.length > 0) {
+                const result = {
+                    collection: currentCollection,
+                    entries: currentEntries,
+                    total: currentEntries.length,
+                };
+                results.push(result);
+                (_a = callbacks.onResult) === null || _a === void 0 ? void 0 : _a.call(callbacks, result);
+            }
+            (_b = callbacks.onDone) === null || _b === void 0 ? void 0 : _b.call(callbacks);
+            resolve(results);
+        });
+        stream.on("error", (err) => {
+            var _a;
+            (_a = callbacks.onError) === null || _a === void 0 ? void 0 : _a.call(callbacks, err.message);
+            reject(err);
+        });
+    });
+}

package/lib/commands/createAccessCommand.js

@@ -0,0 +1,126 @@
+import chalk from "chalk";
+import { modelsAndRights } from "../../data/modelsAndRights.js";
+import { aYOUneModules } from "../../data/modules.js";
+import { isSuperUser, getTokenPayload } from "../helpers/tokenPayload.js";
+import { handleResponseFormatOptions } from "../helpers/handleResponseFormatOptions.js";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+function getAccessibleModules(su) {
+    var _a;
+    const moduleSummaries = [];
+    for (const mod of aYOUneModules) {
+        if (mod.superuserOnly && !su)
+            continue;
+        const collections = modelsAndRights.filter((m) => m.module === mod.module);
+        moduleSummaries.push({
+            module: mod.module,
+            label: mod.label,
+            collections: collections.length,
+            superuserOnly: (_a = mod.superuserOnly) !== null && _a !== void 0 ? _a : false,
+        });
+    }
+    return moduleSummaries;
+}
+function displayAccess(modules, su) {
+    const payload = getTokenPayload();
+    const name = (payload === null || payload === void 0 ? void 0 : payload.name) || (payload === null || payload === void 0 ? void 0 : payload.username) || (payload === null || payload === void 0 ? void 0 : payload.email) || "Unknown";
+    const type = (payload === null || payload === void 0 ? void 0 : payload.type) || "user";
+    console.log();
+    console.log(chalk.bold(`  Access Summary for ${chalk.cyan(name)}`));
+    console.log(chalk.dim(`  Type: ${su ? chalk.yellow("superuser") : type}`));
+    console.log(chalk.dim(`  ${"─".repeat(50)}`));
+    console.log();
+    const totalCollections = modules.reduce((sum, m) => sum + m.collections, 0);
+    // Column widths
+    const maxMod = Math.max(...modules.map((m) => m.module.length), 6);
+    const maxLabel = Math.max(...modules.map((m) => m.label.length), 5);
+    console.log(`  ${chalk.dim("MODULE".padEnd(maxMod + 2))} ${chalk.dim("LABEL".padEnd(maxLabel + 2))} ${chalk.dim("COLLECTIONS")}`);
+    console.log(chalk.dim(`  ${"─".repeat(maxMod + maxLabel + 18)}`));
+    for (const mod of modules) {
+        const modName = mod.superuserOnly
+            ? chalk.yellow(mod.module.padEnd(maxMod + 2))
+            : mod.module.padEnd(maxMod + 2);
+        const label = mod.label.padEnd(maxLabel + 2);
+        const count = String(mod.collections).padStart(4);
+        console.log(`  ${modName} ${label} ${count}`);
+    }
+    console.log();
+    console.log(chalk.dim(`  ${modules.length} modules, ${totalCollections} collections accessible`));
+    if (su) {
+        console.log(chalk.yellow(`  Superuser access: all modules including system collections`));
+    }
+    console.log();
+}
+export function createAccessCommand(program) {
+    program
+        .command("access")
+        .description("Show accessible modules and collections for the current user")
+        .addHelpText("after", `
+Examples:
+  ay access                   Show accessible modules and collection counts
+  ay access -r json            Output as JSON
+  ay access --module crm       Show collections in a specific module`)
+        .option("--module <name>", "Show collections for a specific module")
+        .action(async (options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const su = isSuperUser();
+            const modules = getAccessibleModules(su);
+            // Detail mode: list collections in a specific module
+            if (opts.module) {
+                const modName = opts.module.toLowerCase();
+                const mod = aYOUneModules.find((m) => m.module === modName);
+                if (!mod) {
+                    cliError(`Unknown module: "${opts.module}". Use "ay access" to see available modules.`, EXIT_GENERAL_ERROR);
+                }
+                if (mod.superuserOnly && !su) {
+                    cliError(`Module "${opts.module}" requires superuser access.`, EXIT_GENERAL_ERROR);
+                }
+                const collections = modelsAndRights
+                    .filter((m) => m.module === modName)
+                    .map((m) => ({
+                    collection: m.plural,
+                    singular: m.singular,
+                    right: m.right,
+                }));
+                if (opts.responseFormat !== "json" || opts.save) {
+                    handleResponseFormatOptions(opts, collections);
+                }
+                else {
+                    console.log();
+                    console.log(chalk.bold(`  Collections in ${chalk.cyan(mod.label)} (${modName})`));
+                    console.log(chalk.dim(`  ${"─".repeat(50)}`));
+                    console.log();
+                    const maxCol = Math.max(...collections.map((c) => c.collection.length), 10);
+                    const maxRight = Math.max(...collections.map((c) => c.right.length), 5);
+                    console.log(`  ${chalk.dim("COLLECTION".padEnd(maxCol + 2))} ${chalk.dim("RIGHT")}`);
+                    console.log(chalk.dim(`  ${"─".repeat(maxCol + maxRight + 6)}`));
+                    for (const col of collections) {
+                        console.log(`  ${col.collection.padEnd(maxCol + 2)} ${chalk.dim(col.right)}`);
+                    }
+                    console.log();
+                    console.log(chalk.dim(`  ${collections.length} collections`));
+                    console.log();
+                }
+                return;
+            }
+            // Summary mode: show all accessible modules
+            if (opts.responseFormat !== "json" || opts.save) {
+                // For non-default formats or save, use standard formatting
+                const data = modules.map((m) => ({
+                    module: m.module,
+                    label: m.label,
+                    collections: m.collections,
+                    ...(m.superuserOnly ? { superuserOnly: true } : {}),
+                }));
+                handleResponseFormatOptions(opts, data);
+            }
+            else {
+                displayAccess(modules, su);
+            }
+        }
+        catch (e) {
+            cliError(e.message || "An unexpected error occurred", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createActionsCommand.js

@@ -0,0 +1,140 @@
+import { api, getModuleBaseUrl } from "../api/apiClient.js";
+import { handleResponseFormatOptions } from "../helpers/handleResponseFormatOptions.js";
+import { saveFile } from "../helpers/saveFile.js";
+import { secureStorage } from "../helpers/secureStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_PERMISSION_DENIED } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+export function createActionsCommand(program) {
+    program
+        .command("actions [search]")
+        .alias("act")
+        .description("Discover registered API actions from all services")
+        .addHelpText("after", `
+Examples:
+  ay actions                         List all API actions (interactive)
+  ay actions generate                Search actions matching "generate"
+  ay actions --namespace ai          List all AI actions
+  ay actions --host ai.ayoune.app    List actions for a specific host
+  ay actions --method POST           List only POST actions
+  ay actions --list-namespaces       List all available namespaces
+  ay actions -r table --columns "operationId,method,endpoint,host"`)
+        .option("--namespace <ns>", "Filter by namespace (e.g. ai, crm, pm)")
+        .option("--host <host>", "Filter by host")
+        .option("--method <method>", "Filter by HTTP method (GET, POST, PUT, DELETE)")
+        .option("--capability <cap>", "Filter by capability")
+        .option("--list-namespaces", "List all unique namespaces")
+        .option("--list-hosts", "List all unique hosts")
+        .option("-p, --page <number>", "Page", parseInt, 1)
+        .option("-l, --limit <number>", "Limit", parseInt, 100)
+        .action(async (search, options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching API actions...", color: "magenta" });
+            // Build query params
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: "json",
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            };
+            if (search)
+                params.q = search;
+            // Try su module first (full access), fall back to config module (limited access)
+            const modules = ["su", "config"];
+            let res = null;
+            let permissionDenied = false;
+            for (const mod of modules) {
+                try {
+                    const token = secureStorage.getItem("token") || "";
+                    const response = await api({
+                        baseURL: getModuleBaseUrl(mod),
+                        method: "get",
+                        url: "ayouneapiactions",
+                        params,
+                        headers: { Authorization: `Bearer ${token}` },
+                    });
+                    res = response.data;
+                    if (res === null || res === void 0 ? void 0 : res.payload)
+                        break;
+                }
+                catch (e) {
+                    // On 401/403 permission denied, try next module
+                    if (((_a = e.response) === null || _a === void 0 ? void 0 : _a.status) === 403 || ((_b = e.response) === null || _b === void 0 ? void 0 : _b.status) === 401) {
+                        permissionDenied = true;
+                        continue;
+                    }
+                    // For other errors (network, 500, etc.), only throw on last module
+                    if (mod === modules[modules.length - 1])
+                        throw e;
+                }
+            }
+            if (!(res === null || res === void 0 ? void 0 : res.payload)) {
+                if (permissionDenied) {
+                    cliError("Permission denied: you do not have access to query API actions. Contact your administrator for the required rights.", EXIT_PERMISSION_DENIED, "permission_denied");
+                }
+                spinner.error({ text: "No API actions found" });
+                return;
+            }
+            let actions = Array.isArray(res.payload) ? res.payload : [res.payload];
+            // Apply client-side filters
+            if (opts.namespace) {
+                actions = actions.filter((a) => a.nameSpace === opts.namespace);
+            }
+            if (opts.host) {
+                actions = actions.filter((a) => { var _a; return (_a = a.host) === null || _a === void 0 ? void 0 : _a.includes(opts.host); });
+            }
+            if (opts.method) {
+                actions = actions.filter((a) => { var _a; return ((_a = a.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) === opts.method.toUpperCase(); });
+            }
+            if (opts.capability) {
+                actions = actions.filter((a) => a.capability === opts.capability);
+            }
+            // Special modes: list namespaces or hosts
+            if (opts.listNamespaces) {
+                const namespaces = [...new Set(actions.map((a) => a.nameSpace).filter(Boolean))].sort();
+                spinner.success({ text: `Found ${namespaces.length} namespaces` });
+                spinner.stop();
+                console.log(namespaces.join("\n"));
+                return;
+            }
+            if (opts.listHosts) {
+                const hosts = [...new Set(actions.map((a) => a.host).filter(Boolean))].sort();
+                spinner.success({ text: `Found ${hosts.length} hosts` });
+                spinner.stop();
+                console.log(hosts.join("\n"));
+                return;
+            }
+            // Filter out deprecated
+            actions = actions.filter((a) => !a.deprecated);
+            // Build display-friendly response
+            const formattedRes = {
+                payload: actions.map((a) => ({
+                    operationId: a.operationId || "",
+                    method: (a.method || "GET").toUpperCase(),
+                    endpoint: a.endpoint || "",
+                    host: a.host || "",
+                    nameSpace: a.nameSpace || "",
+                    capability: a.capability || "",
+                    action: a.action || "",
+                    description: a.shortDescription || a.description || "",
+                })),
+                meta: {
+                    ...res.meta,
+                    pageInfo: { ...(_c = res.meta) === null || _c === void 0 ? void 0 : _c.pageInfo, totalEntries: actions.length },
+                },
+            };
+            const { plainResult, result, content } = handleResponseFormatOptions(opts, formattedRes);
+            spinner.success({ text: `Found ${actions.length} API actions` });
+            spinner.stop();
+            if (opts.save) {
+                await saveFile("actions", opts, formattedRes);
+            }
+        }
+        catch (e) {
+            cliError(e.message || "Failed to fetch API actions", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createAiCommand.js

@@ -0,0 +1,188 @@
+import { apiCallHandler } from "../api/apiCallHandler.js";
+import { api } from "../api/apiClient.js";
+import { handleResponseFormatOptions } from "../helpers/handleResponseFormatOptions.js";
+import { saveFile } from "../helpers/saveFile.js";
+import { secureStorage } from "../helpers/secureStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+import { getContextSummary, getContextForAI, hasActiveContext } from "../helpers/contextInjector.js";
+const AI_HOST = "ai.ayoune.app";
+export function createAiCommand(program) {
+    const ai = program
+        .command("ai")
+        .description("Interact with aYOUne AI services");
+    // ay ai actions — list all AI endpoints
+    ai.command("actions")
+        .description("List all registered AI API actions")
+        .action(async () => {
+        try {
+            const opts = { ...program.opts() };
+            spinner.start({ text: "Fetching AI actions...", color: "magenta" });
+            const res = await apiCallHandler("su", "ayouneapiactions", "get", null, {
+                q: "ai",
+                limit: 200,
+                responseFormat: "json",
+            });
+            if (!(res === null || res === void 0 ? void 0 : res.payload)) {
+                spinner.error({ text: "No AI actions found" });
+                return;
+            }
+            const actions = (Array.isArray(res.payload) ? res.payload : [])
+                .filter((a) => a.nameSpace === "ai" && !a.deprecated)
+                .map((a) => ({
+                operationId: a.operationId || "",
+                method: (a.method || "GET").toUpperCase(),
+                endpoint: a.endpoint || "",
+                description: a.shortDescription || a.description || "",
+            }));
+            const formattedRes = {
+                payload: actions,
+                meta: { responseTime: 0, pageInfo: { totalEntries: actions.length, page: 1, totalPages: 1 } },
+            };
+            handleResponseFormatOptions(opts, formattedRes);
+            spinner.success({ text: `Found ${actions.length} AI actions` });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to fetch AI actions", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay ai conversations — list AI conversations
+    ai.command("conversations")
+        .description("List AI conversations")
+        .option("-l, --limit <number>", "Limit", parseInt, 20)
+        .option("-p, --page <number>", "Page", parseInt, 1)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching AI conversations...", color: "magenta" });
+            const res = await apiCallHandler("ai", "aiconversations", "get", null, {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            });
+            const { plainResult, result, content } = handleResponseFormatOptions(opts, res);
+            const total = (_c = (_b = (_a = res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo) === null || _b === void 0 ? void 0 : _b.totalEntries) !== null && _c !== void 0 ? _c : 0;
+            spinner.success({ text: `Got ${total} AI conversations` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("ai-conversations", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list conversations", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay ai prompts — list AI prompt templates
+    ai.command("prompts")
+        .description("List AI prompt templates")
+        .option("-l, --limit <number>", "Limit", parseInt, 20)
+        .option("-p, --page <number>", "Page", parseInt, 1)
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...program.opts(), ...options };
+            spinner.start({ text: "Fetching AI prompts...", color: "magenta" });
+            const res = await apiCallHandler("ai", "aiprompts", "get", null, {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            });
+            const { plainResult, result, content } = handleResponseFormatOptions(opts, res);
+            const total = (_c = (_b = (_a = res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo) === null || _b === void 0 ? void 0 : _b.totalEntries) !== null && _c !== void 0 ? _c : 0;
+            spinner.success({ text: `Got ${total} AI prompts` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("ai-prompts", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list prompts", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay ai ask <prompt> — send a prompt to AI
+    ai.command("ask <prompt...>")
+        .description("Send a prompt to aYOUne AI")
+        .option("--conversation <id>", "Continue an existing conversation")
+        .option("--model <model>", "AI model to use")
+        .action(async (promptWords, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const prompt = promptWords.join(" ");
+            spinner.start({ text: "Sending prompt to AI...", color: "magenta" });
+            const body = { prompt };
+            if (opts.conversation)
+                body.conversationId = opts.conversation;
+            if (opts.model)
+                body.model = opts.model;
+            if (hasActiveContext()) {
+                body.context = getContextForAI();
+                body.prompt = `${getContextSummary()}\n\nUser question: ${prompt}`;
+            }
+            const res = await apiCallHandler("ai", "ask", "post", body, {
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+                hideMeta: opts.hideMeta,
+            });
+            const { plainResult, result, content } = handleResponseFormatOptions(opts, res);
+            spinner.success({ text: "AI response received" });
+            spinner.stop();
+            if (opts.save)
+                await saveFile("ai-ask", opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "AI request failed", EXIT_GENERAL_ERROR);
+        }
+    });
+    // ay ai generate <type> <prompt> — generate content
+    ai.command("generate <type> <prompt...>")
+        .description("Generate content (text, image, video)")
+        .addHelpText("after", `
+Types: text, image, video
+
+Examples:
+  ay ai generate text "Write a product description for..."
+  ay ai generate image "A modern office building"`)
+        .action(async (type, promptWords, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const prompt = promptWords.join(" ");
+            const typeHostMap = {
+                text: "text-generation",
+                image: "image-generation",
+                video: "video-generation",
+            };
+            const host = typeHostMap[type];
+            if (!host) {
+                cliError(`Unknown type: ${type}. Use: text, image, video`, EXIT_GENERAL_ERROR);
+            }
+            spinner.start({ text: `Generating ${type}...`, color: "magenta" });
+            const response = await api({
+                baseURL: `https://${host}.ayoune.app`,
+                method: "post",
+                url: "/generate",
+                data: { prompt },
+                params: {
+                    responseFormat: opts.responseFormat,
+                    verbosity: opts.verbosity,
+                },
+                headers: {
+                    Authorization: `Bearer ${secureStorage.getItem("token")}`,
+                },
+            });
+            const res = response.data;
+            handleResponseFormatOptions(opts, res);
+            spinner.success({ text: `${type} generation complete` });
+            spinner.stop();
+            if (opts.save)
+                await saveFile(`ai-generate-${type}`, opts, res);
+        }
+        catch (e) {
+            cliError(e.message || `${type} generation failed`, EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createAliasCommand.js

@@ -0,0 +1,104 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import path from "path";
+import os from "os";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+import { spinner } from "../../index.js";
+import { cliError } from "../helpers/cliError.js";
+const ALIASES_PATH = path.join(os.homedir(), ".config", "ayoune", "aliases.json");
+export function loadAliases() {
+    if (!existsSync(ALIASES_PATH)) {
+        return {};
+    }
+    try {
+        return JSON.parse(readFileSync(ALIASES_PATH, "utf-8"));
+    }
+    catch (_a) {
+        return {};
+    }
+}
+function saveAliases(aliases) {
+    const dir = path.dirname(ALIASES_PATH);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(ALIASES_PATH, JSON.stringify(aliases, null, 2), "utf-8");
+}
+export function createAliasCommand(program) {
+    const alias = program
+        .command("alias")
+        .description("Manage custom command aliases")
+        .addHelpText("after", `
+Examples:
+  ay alias set ll "list leads"       Create alias 'll' for 'list leads'
+  ay alias list                      Show all custom aliases
+  ay alias remove ll                 Remove the 'll' alias`);
+    alias
+        .command("set <name> <command>")
+        .description("Create or update a custom alias")
+        .action((name, command) => {
+        try {
+            const aliases = loadAliases();
+            aliases[name] = command;
+            saveAliases(aliases);
+            spinner.success({ text: `Alias '${name}' set to '${command}'` });
+        }
+        catch (e) {
+            cliError(e.message || "Failed to save alias", EXIT_GENERAL_ERROR);
+        }
+    });
+    alias
+        .command("list")
+        .description("List all custom aliases")
+        .action(() => {
+        const aliases = loadAliases();
+        const entries = Object.entries(aliases);
+        if (entries.length === 0) {
+            console.log("No custom aliases defined.");
+            return;
+        }
+        for (const [name, command] of entries) {
+            console.log(`  ${name} -> ${command}`);
+        }
+    });
+    alias
+        .command("remove <name>")
+        .description("Remove a custom alias")
+        .action((name) => {
+        try {
+            const aliases = loadAliases();
+            if (!(name in aliases)) {
+                cliError(`Alias '${name}' not found`, EXIT_MISUSE);
+            }
+            delete aliases[name];
+            saveAliases(aliases);
+            spinner.success({ text: `Alias '${name}' removed` });
+        }
+        catch (e) {
+            cliError(e.message || "Failed to remove alias", EXIT_GENERAL_ERROR);
+        }
+    });
+}
+export function registerUserAliases(program) {
+    const aliases = loadAliases();
+    for (const [name, command] of Object.entries(aliases)) {
+        // Check if we'd conflict with a built-in command
+        const existing = program.commands.find((cmd) => cmd.name() === name || cmd.aliases().includes(name));
+        if (existing)
+            continue;
+        program
+            .command(name)
+            .description(`Alias for '${command}'`)
+            .allowUnknownOption()
+            .allowExcessArguments()
+            .action(async (...args) => {
+            // Re-parse with the aliased command substituted in
+            const argv = process.argv.slice(0, 2).concat(command.split(/\s+/));
+            // Append any extra args passed after the alias
+            const extraArgs = args.slice(0, -1); // last arg is the Command object
+            if (Array.isArray(extraArgs[0])) {
+                argv.push(...extraArgs[0]);
+            }
+            program.parse(argv);
+        });
+    }
+}