@tolinax/ayoune-cli 2026.2.1 → 2026.2.2

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 { localStorage } from "../helpers/localStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.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("config", "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) {
+            spinner.error({ text: e.message || "Failed to fetch AI actions" });
+            process.exit(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", "conversations", "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) {
+            spinner.error({ text: e.message || "Failed to list conversations" });
+            process.exit(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", "prompts", "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) {
+            spinner.error({ text: e.message || "Failed to list prompts" });
+            process.exit(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;
+            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) {
+            spinner.error({ text: e.message || "AI request failed" });
+            process.exit(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) {
+                spinner.error({ text: `Unknown type: ${type}. Use: text, image, video` });
+                process.exit(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 ${localStorage.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) {
+            spinner.error({ text: e.message || `${type} generation failed` });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createAliasCommand.js

@@ -0,0 +1,106 @@
+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";
+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) {
+            spinner.error({ text: e.message || "Failed to save alias" });
+            process.exit(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)) {
+                spinner.error({ text: `Alias '${name}' not found` });
+                process.exit(EXIT_MISUSE);
+            }
+            delete aliases[name];
+            saveAliases(aliases);
+            spinner.success({ text: `Alias '${name}' removed` });
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "Failed to remove alias" });
+            process.exit(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);
+        });
+    }
+}

package/lib/commands/createAuditCommand.js

@@ -0,0 +1,49 @@
+import { Argument } from "commander";
+import { localStorage } from "../helpers/localStorage.js";
+import { handleAuditOperation } from "../operations/handleAuditOperation.js";
+import { promptAudits } from "../prompts/promptAudits.js";
+import { handleSingleAuditOperation } from "../operations/handleSingleAuditOperation.js";
+import yaml from "js-yaml";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+export function createAuditCommand(program) {
+    program
+        .command("audit")
+        .addArgument(new Argument("[collection]", "The collection to use").default(localStorage.getItem("lastCollection"), `The last used collection (${localStorage.getItem("lastCollection")})`))
+        .addArgument(new Argument("[id]", "The id to get the audit from").default(localStorage.getItem("lastId"), `The last used id (${localStorage.getItem("lastId")})`))
+        .alias("history")
+        .description("View the change history of an entry")
+        .addHelpText("after", `
+Examples:
+  ay audit contacts 64a1b2c3d4e5     View audit trail for a contact
+  ay history                          View audit for last used entry`)
+        .action(async (collection, id, options) => {
+        try {
+            if (!collection) {
+                spinner.error({ text: "Missing required argument: collection. Run a list or get command first, or provide it explicitly." });
+                process.exit(EXIT_MISUSE);
+            }
+            if (!id) {
+                spinner.error({ text: "Missing required argument: id. Provide an entry ID explicitly." });
+                process.exit(EXIT_MISUSE);
+            }
+            const opts = { ...program.opts(), ...options };
+            const { data, content, result, meta } = await handleAuditOperation(collection, id, {
+                ...opts,
+            });
+            if (!process.stdin.isTTY) {
+                spinner.error({ text: "The audit command requires an interactive terminal for audit selection" });
+                process.exit(EXIT_MISUSE);
+            }
+            const selectedAudit = await promptAudits(result);
+            const { singleData, singleContent, singleResult, singleMeta } = await handleSingleAuditOperation(collection, id, selectedAudit, {
+                ...opts,
+            });
+            console.log(yaml.dump(singleContent));
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createCompletionsCommand.js

@@ -0,0 +1,136 @@
+const BASH_COMPLETION = `###-begin-ay-completions-###
+_ay_completions() {
+  local cur commands
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  commands="modules list get edit copy create describe audit stream events storage whoami login logout completions alias config actions exec ai services deploy monitor"
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+  fi
+}
+complete -F _ay_completions ay
+###-end-ay-completions-###`;
+const ZSH_COMPLETION = `###-begin-ay-completions-###
+_ay() {
+  local -a commands
+  commands=(
+    'modules:Browse modules interactively'
+    'list:List entries in a collection'
+    'get:Get entries from a collection'
+    'edit:Edit an entry in a collection'
+    'copy:Copy an entry in a collection'
+    'create:Create a new entry in a collection'
+    'describe:Describe an entry in a collection'
+    'audit:View audit history of an entry'
+    'stream:Attach to the live data stream'
+    'events:Attach to the live event bus'
+    'storage:Show current local storage'
+    'whoami:Show your user information'
+    'login:Login to your aYOUne account'
+    'logout:Logout from your aYOUne account'
+    'completions:Generate shell completion script'
+    'alias:Manage command aliases'
+    'config:Manage CLI configuration'
+    'actions:Discover registered API actions'
+    'exec:Execute any API action by operationId'
+    'ai:AI assistant commands'
+    'services:Discover and manage platform services'
+    'deploy:Manage deployments and pipelines'
+    'monitor:Monitor platform activity, logs, and alerts'
+  )
+  _describe 'command' commands
+}
+compdef _ay ay
+###-end-ay-completions-###`;
+const FISH_COMPLETION = `###-begin-ay-completions-###
+complete -c ay -n '__fish_use_subcommand' -a modules -d 'Browse modules interactively'
+complete -c ay -n '__fish_use_subcommand' -a list -d 'List entries in a collection'
+complete -c ay -n '__fish_use_subcommand' -a get -d 'Get entries from a collection'
+complete -c ay -n '__fish_use_subcommand' -a edit -d 'Edit an entry in a collection'
+complete -c ay -n '__fish_use_subcommand' -a copy -d 'Copy an entry in a collection'
+complete -c ay -n '__fish_use_subcommand' -a create -d 'Create a new entry in a collection'
+complete -c ay -n '__fish_use_subcommand' -a describe -d 'Describe an entry in a collection'
+complete -c ay -n '__fish_use_subcommand' -a audit -d 'View audit history of an entry'
+complete -c ay -n '__fish_use_subcommand' -a stream -d 'Attach to the live data stream'
+complete -c ay -n '__fish_use_subcommand' -a events -d 'Attach to the live event bus'
+complete -c ay -n '__fish_use_subcommand' -a storage -d 'Show current local storage'
+complete -c ay -n '__fish_use_subcommand' -a whoami -d 'Show your user information'
+complete -c ay -n '__fish_use_subcommand' -a login -d 'Login to your aYOUne account'
+complete -c ay -n '__fish_use_subcommand' -a logout -d 'Logout from your aYOUne account'
+complete -c ay -n '__fish_use_subcommand' -a completions -d 'Generate shell completion script'
+complete -c ay -n '__fish_use_subcommand' -a alias -d 'Manage command aliases'
+complete -c ay -n '__fish_use_subcommand' -a config -d 'Manage CLI configuration'
+complete -c ay -n '__fish_use_subcommand' -a actions -d 'Discover registered API actions'
+complete -c ay -n '__fish_use_subcommand' -a exec -d 'Execute any API action by operationId'
+complete -c ay -n '__fish_use_subcommand' -a ai -d 'AI assistant commands'
+complete -c ay -n '__fish_use_subcommand' -a services -d 'Discover and manage platform services'
+complete -c ay -n '__fish_use_subcommand' -a deploy -d 'Manage deployments and pipelines'
+complete -c ay -n '__fish_use_subcommand' -a monitor -d 'Monitor platform activity, logs, and alerts'
+###-end-ay-completions-###`;
+const POWERSHELL_COMPLETION = `###-begin-ay-completions-###
+Register-ArgumentCompleter -CommandName ay -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $commands = @(
+    @{ Name = 'modules'; Description = 'Browse modules interactively' }
+    @{ Name = 'list'; Description = 'List entries in a collection' }
+    @{ Name = 'get'; Description = 'Get entries from a collection' }
+    @{ Name = 'edit'; Description = 'Edit an entry in a collection' }
+    @{ Name = 'copy'; Description = 'Copy an entry in a collection' }
+    @{ Name = 'create'; Description = 'Create a new entry in a collection' }
+    @{ Name = 'describe'; Description = 'Describe an entry in a collection' }
+    @{ Name = 'audit'; Description = 'View audit history of an entry' }
+    @{ Name = 'stream'; Description = 'Attach to the live data stream' }
+    @{ Name = 'events'; Description = 'Attach to the live event bus' }
+    @{ Name = 'storage'; Description = 'Show current local storage' }
+    @{ Name = 'whoami'; Description = 'Show your user information' }
+    @{ Name = 'login'; Description = 'Login to your aYOUne account' }
+    @{ Name = 'logout'; Description = 'Logout from your aYOUne account' }
+    @{ Name = 'completions'; Description = 'Generate shell completion script' }
+    @{ Name = 'alias'; Description = 'Manage command aliases' }
+    @{ Name = 'config'; Description = 'Manage CLI configuration' }
+    @{ Name = 'actions'; Description = 'Discover registered API actions' }
+    @{ Name = 'exec'; Description = 'Execute any API action by operationId' }
+    @{ Name = 'ai'; Description = 'AI assistant commands' }
+    @{ Name = 'services'; Description = 'Discover and manage platform services' }
+    @{ Name = 'deploy'; Description = 'Manage deployments and pipelines' }
+    @{ Name = 'monitor'; Description = 'Monitor platform activity, logs, and alerts' }
+  )
+  $commands | Where-Object { $_.Name -like "$wordToComplete*" } | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ParameterValue', $_.Description)
+  }
+}
+###-end-ay-completions-###`;
+export function createCompletionsCommand(program) {
+    program
+        .command("completions")
+        .alias("completion")
+        .description("Generate shell completion script")
+        .addHelpText("after", `
+Examples:
+  ay completions bash >> ~/.bashrc        Add bash completions
+  ay completions zsh >> ~/.zshrc          Add zsh completions
+  ay completions fish > ~/.config/fish/completions/ay.fish
+  ay completions powershell >> $PROFILE   Add PowerShell completions`)
+        .argument("<shell>", "Shell type (bash, zsh, fish, powershell)")
+        .action((shell) => {
+        switch (shell) {
+            case "bash":
+                console.log(BASH_COMPLETION);
+                break;
+            case "zsh":
+                console.log(ZSH_COMPLETION);
+                break;
+            case "fish":
+                console.log(FISH_COMPLETION);
+                break;
+            case "powershell":
+            case "pwsh":
+                console.log(POWERSHELL_COMPLETION);
+                break;
+            default:
+                console.error(`Unknown shell: ${shell}. Supported: bash, zsh, fish, powershell`);
+                process.exit(2);
+        }
+    });
+}