@tolinax/ayoune-cli 2026.3.1 → 2026.4.0

package/lib/commands/createConfigCommand.js

@@ -0,0 +1,202 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { loadConfig, saveConfig } from "../helpers/configLoader.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+import { spinner } from "../../index.js";
+import { cliError } from "../helpers/cliError.js";
+const SETTABLE_KEYS = {
+    responseFormat: { type: "string", choices: ["json", "csv", "yaml", "table"] },
+    verbosity: { type: "string", choices: ["default", "extended", "minimal"] },
+    outPath: { type: "string" },
+    hideMeta: { type: "boolean" },
+    quiet: { type: "boolean" },
+    force: { type: "boolean" },
+    dryRun: { type: "boolean" },
+};
+function parseBoolean(value) {
+    const truthy = ["true", "1", "yes", "on"];
+    const falsy = ["false", "0", "no", "off"];
+    if (truthy.includes(value.toLowerCase()))
+        return true;
+    if (falsy.includes(value.toLowerCase()))
+        return false;
+    return null;
+}
+function displayDefaults(defaults) {
+    const entries = Object.entries(SETTABLE_KEYS);
+    const maxLabel = Math.max(...entries.map(([k]) => k.length));
+    console.log();
+    console.log(chalk.bold("  Default Options"));
+    console.log(chalk.dim(`  ${"─".repeat(44)}`));
+    for (const [key] of entries) {
+        const value = defaults[key];
+        const display = value !== undefined && value !== null ? String(value) : chalk.dim("(not set)");
+        console.log(`  ${chalk.dim(key.padEnd(maxLabel + 2))} ${chalk.white(display)}`);
+    }
+    console.log();
+}
+export function createConfigCommand(program) {
+    const config = program
+        .command("config")
+        .description("Manage default CLI options")
+        .addHelpText("after", `
+Examples:
+  ay config                            Interactive defaults menu
+  ay config set responseFormat yaml     Set default response format
+  ay config get responseFormat          Show current response format default
+  ay config list                        Show all defaults
+  ay config reset                       Clear all defaults`)
+        .action(async () => {
+        var _a, _b, _c, _d, _e;
+        try {
+            const cfg = loadConfig();
+            const defaults = (_a = cfg.defaults) !== null && _a !== void 0 ? _a : {};
+            const answers = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "responseFormat",
+                    message: "Default response format",
+                    choices: ["json", "csv", "yaml", "table"],
+                    default: defaults.responseFormat || "json",
+                },
+                {
+                    type: "list",
+                    name: "verbosity",
+                    message: "Default verbosity level",
+                    choices: ["default", "extended", "minimal"],
+                    default: defaults.verbosity || "default",
+                },
+                {
+                    type: "confirm",
+                    name: "hideMeta",
+                    message: "Hide meta information by default?",
+                    default: (_b = defaults.hideMeta) !== null && _b !== void 0 ? _b : false,
+                },
+                {
+                    type: "confirm",
+                    name: "quiet",
+                    message: "Quiet mode by default?",
+                    default: (_c = defaults.quiet) !== null && _c !== void 0 ? _c : false,
+                },
+                {
+                    type: "confirm",
+                    name: "force",
+                    message: "Skip confirmation prompts by default?",
+                    default: (_d = defaults.force) !== null && _d !== void 0 ? _d : false,
+                },
+                {
+                    type: "confirm",
+                    name: "dryRun",
+                    message: "Dry-run mode by default?",
+                    default: (_e = defaults.dryRun) !== null && _e !== void 0 ? _e : false,
+                },
+                {
+                    type: "input",
+                    name: "outPath",
+                    message: "Default output path (leave blank to keep current)",
+                    default: defaults.outPath || "",
+                },
+            ]);
+            const newDefaults = {
+                responseFormat: answers.responseFormat,
+                verbosity: answers.verbosity,
+                hideMeta: answers.hideMeta,
+                quiet: answers.quiet,
+                force: answers.force,
+                dryRun: answers.dryRun,
+            };
+            if (answers.outPath) {
+                newDefaults.outPath = answers.outPath;
+            }
+            cfg.defaults = newDefaults;
+            saveConfig(cfg);
+            displayDefaults(newDefaults);
+            spinner.success({ text: "Defaults saved" });
+        }
+        catch (e) {
+            cliError(e.message || "Failed to save config", EXIT_GENERAL_ERROR);
+        }
+    });
+    config
+        .command("set <key> <value>")
+        .description("Set a default option value")
+        .action((key, value) => {
+        var _a;
+        try {
+            const meta = SETTABLE_KEYS[key];
+            if (!meta) {
+                cliError(`Unknown config key '${key}'. Valid keys: ${Object.keys(SETTABLE_KEYS).join(", ")}`, EXIT_MISUSE);
+            }
+            let parsed = value;
+            if (meta.type === "boolean") {
+                parsed = parseBoolean(value);
+                if (parsed === null) {
+                    cliError(`Invalid boolean value '${value}'. Use true/false, yes/no, 1/0, on/off`, EXIT_MISUSE);
+                }
+            }
+            else if (meta.choices && !meta.choices.includes(value)) {
+                cliError(`Invalid value '${value}' for ${key}. Choices: ${meta.choices.join(", ")}`, EXIT_MISUSE);
+            }
+            const cfg = loadConfig();
+            cfg.defaults = (_a = cfg.defaults) !== null && _a !== void 0 ? _a : {};
+            cfg.defaults[key] = parsed;
+            saveConfig(cfg);
+            spinner.success({ text: `${key} set to '${parsed}'` });
+        }
+        catch (e) {
+            cliError(e.message || "Failed to save config", EXIT_GENERAL_ERROR);
+        }
+    });
+    config
+        .command("get <key>")
+        .description("Show a default option value")
+        .action((key) => {
+        var _a;
+        if (!SETTABLE_KEYS[key]) {
+            cliError(`Unknown config key '${key}'. Valid keys: ${Object.keys(SETTABLE_KEYS).join(", ")}`, EXIT_MISUSE);
+        }
+        const cfg = loadConfig();
+        const value = (_a = cfg.defaults) === null || _a === void 0 ? void 0 : _a[key];
+        if (value !== undefined && value !== null) {
+            console.log(value);
+        }
+        else {
+            console.log(chalk.dim("(not set)"));
+        }
+    });
+    config
+        .command("list")
+        .description("Show all default options")
+        .action(() => {
+        var _a;
+        const cfg = loadConfig();
+        displayDefaults((_a = cfg.defaults) !== null && _a !== void 0 ? _a : {});
+    });
+    config
+        .command("reset")
+        .description("Clear all default options")
+        .action(async (options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (!opts.force) {
+                const { confirm } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "confirm",
+                        message: "Reset all defaults to factory settings?",
+                        default: false,
+                    },
+                ]);
+                if (!confirm)
+                    return;
+            }
+            const cfg = loadConfig();
+            cfg.defaults = {};
+            saveConfig(cfg);
+            spinner.success({ text: "All defaults have been reset" });
+        }
+        catch (e) {
+            cliError(e.message || "Failed to reset config", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createContextCommand.js

@@ -0,0 +1,163 @@
+import chalk from "chalk";
+import { spinner } from "../../index.js";
+import { contextSlots, getSlot, getSlotsByTier } from "../../data/contextSlots.js";
+import { getActiveContext, setContextEntry, unsetContextEntry, clearAllContext, } from "../helpers/contextStore.js";
+import { resolveEntity, validateHierarchy, getDependentSlots } from "../helpers/contextResolver.js";
+import { EXIT_MISUSE } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+export function createContextCommand(program) {
+    const ctx = program
+        .command("context")
+        .alias("ctx")
+        .description("Manage active entity context for scoped commands")
+        .addHelpText("after", `
+Examples:
+  ay context                              Show active context
+  ay context set project "Website"        Set project context by name
+  ay context set sprint "Sprint 14"       Set sprint (auto-filtered by project)
+  ay context unset project                Unset project (cascades to children)
+  ay context clear                        Clear all context
+  ay context list                         List all available context slots`);
+    // Default action: show active context
+    ctx.action(() => {
+        showContext();
+    });
+    // ay context show
+    ctx
+        .command("show")
+        .description("Show active context")
+        .action(() => {
+        showContext();
+    });
+    // ay context set <slot> <name>
+    ctx
+        .command("set <slot> <nameOrId...>")
+        .description("Set active context for a slot")
+        .action(async (slot, nameOrIdParts, options) => {
+        const opts = { ...program.opts(), ...options };
+        const nameOrId = nameOrIdParts.join(" ");
+        const slotDef = getSlot(slot);
+        if (!slotDef) {
+            const available = contextSlots.map((s) => s.slot).join(", ");
+            cliError(`Unknown context slot: "${slot}". Available: ${available}`, EXIT_MISUSE);
+            return;
+        }
+        // Hierarchy warning
+        const warning = validateHierarchy(slot);
+        if (warning) {
+            console.error(chalk.yellow(`  ${warning}`));
+        }
+        spinner.start({ text: `Resolving ${slot} "${nameOrId}"...`, color: "magenta" });
+        const matches = await resolveEntity(slot, nameOrId);
+        if (matches.length === 0) {
+            spinner.error({ text: `No ${slot} found matching "${nameOrId}"` });
+            spinner.stop();
+            return;
+        }
+        let selected = matches[0];
+        // If multiple matches and interactive TTY, let user pick
+        if (matches.length > 1 && process.stdin.isTTY) {
+            spinner.stop();
+            console.error(chalk.dim(`  Multiple matches for "${nameOrId}":`));
+            matches.forEach((m, i) => {
+                console.error(`  ${chalk.cyan(`[${i + 1}]`)} ${m.name} ${chalk.dim(`(${m.id})`)}`);
+            });
+            console.error(chalk.dim(`  Using first match. Use an ObjectId for exact selection.\n`));
+            selected = matches[0];
+        }
+        else if (matches.length > 1) {
+            spinner.stop();
+        }
+        setContextEntry(slot, {
+            id: selected.id,
+            name: selected.name,
+            collection: slotDef.collection,
+            module: slotDef.module,
+            setAt: new Date().toISOString(),
+        });
+        spinner.success({ text: `Context ${slot} set to "${selected.name}" (${selected.id})` });
+        spinner.stop();
+    });
+    // ay context unset <slot>
+    ctx
+        .command("unset <slot>")
+        .description("Remove context for a slot (cascades to children)")
+        .action((slot) => {
+        const slotDef = getSlot(slot);
+        if (!slotDef) {
+            cliError(`Unknown context slot: "${slot}"`, EXIT_MISUSE);
+            return;
+        }
+        // Cascade unset children
+        const children = getDependentSlots(slot);
+        const unset = [slot];
+        for (const child of children) {
+            const entry = getActiveContext()[child];
+            if (entry) {
+                unsetContextEntry(child);
+                unset.push(child);
+            }
+        }
+        unsetContextEntry(slot);
+        if (unset.length > 1) {
+            console.error(chalk.dim(`  Cascade: also unset ${unset.slice(1).join(", ")}`));
+        }
+        spinner.success({ text: `Context "${slot}" unset` });
+        spinner.stop();
+    });
+    // ay context clear
+    ctx
+        .command("clear")
+        .description("Clear all active context")
+        .option("--force", "Skip confirmation")
+        .action((options) => {
+        const opts = { ...program.opts(), ...options };
+        const active = getActiveContext();
+        const count = Object.keys(active).length;
+        if (count === 0) {
+            console.error(chalk.dim("  No active context to clear."));
+            return;
+        }
+        clearAllContext();
+        spinner.success({ text: `Cleared ${count} context entries` });
+        spinner.stop();
+    });
+    // ay context list
+    ctx
+        .command("list")
+        .description("List all available context slots")
+        .action(() => {
+        const active = getActiveContext();
+        const tierLabels = {
+            1: "Core",
+            2: "Domain",
+            3: "AI / Automation",
+        };
+        for (const tier of [1, 2, 3]) {
+            const slots = getSlotsByTier(tier);
+            console.log(chalk.bold(`\n  ${tierLabels[tier]}`));
+            for (const s of slots) {
+                const entry = active[s.slot];
+                const status = entry
+                    ? chalk.green(`= "${entry.name}" (${entry.id})`)
+                    : chalk.dim("not set");
+                const parent = s.parent ? chalk.dim(` [parent: ${s.parent}]`) : "";
+                console.log(`    ${chalk.cyan(s.slot.padEnd(14))} ${s.collection.padEnd(22)} ${status}${parent}`);
+            }
+        }
+        console.log();
+    });
+}
+function showContext() {
+    const active = getActiveContext();
+    const entries = Object.entries(active);
+    if (entries.length === 0) {
+        console.log(chalk.dim("  No active context. Use `ay context set <slot> <name>` to set one."));
+        return;
+    }
+    console.log(chalk.bold("\n  Active Context"));
+    for (const [slot, entry] of entries) {
+        console.log(`    ${chalk.cyan(slot.padEnd(14))} ${entry.name} ${chalk.dim(`(${entry.collection}, ${entry.id})`)}`);
+    }
+    console.log();
+}

package/lib/commands/createCopyCommand.js

@@ -0,0 +1,36 @@
+import { Argument } from "commander";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { handleCopySingleOperation } from "../operations/handleCopySingleOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+export function createCopyCommand(program) {
+    program
+        .command("copy")
+        .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 of the entry to copy").default(localStorage.getItem("lastId"), `The last used id (${localStorage.getItem("lastId")})`))
+        .alias("cp")
+        .description("Duplicate an entry by ID in a collection")
+        .addHelpText("after", `
+Examples:
+  ay copy contacts 64a1b2c3d4e5     Copy a contact entry
+  ay cp                              Copy last used entry`)
+        .action(async (collection, id, options) => {
+        try {
+            if (!collection) {
+                cliError("Missing required argument: collection. Run a list or get command first, or provide it explicitly.", EXIT_MISUSE);
+            }
+            if (!id) {
+                cliError("Missing required argument: id. Provide an entry ID explicitly.", EXIT_MISUSE);
+            }
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            await handleCopySingleOperation(module.module, collection, id, {
+                ...opts,
+            });
+        }
+        catch (e) {
+            cliError(e.message || "An unexpected error occurred", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createCreateCommand.js

@@ -0,0 +1,47 @@
+import { Argument } from "commander";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { promptCollectionWithModule } from "../prompts/promptCollectionWithModule.js";
+import { handleCreateSingleOperation } from "../operations/handleCreateSingleOperation.js";
+import { promptName } from "../prompts/promptName.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+export function createCreateCommand(program) {
+    program
+        .command("create")
+        .alias("c")
+        .addArgument(new Argument("[collection]", "The collection to use").default(localStorage.getItem("lastCollection"), `The last used collection (${localStorage.getItem("lastCollection")})`))
+        .addArgument(new Argument("[name]", "The name of the new item"))
+        .description("Create a new entry in a collection")
+        .addHelpText("after", `
+Examples:
+  ay create contacts "John Doe"     Create a new contact
+  ay c products "Widget"            Create a new product using alias`)
+        .action(async (collection, name, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (!collection) {
+                if (!process.stdin.isTTY) {
+                    cliError("Missing required argument: collection", EXIT_MISUSE);
+                }
+                collection = await promptCollectionWithModule();
+            }
+            const module = getModuleFromCollection(collection);
+            let entryName = name;
+            if (!entryName) {
+                if (!process.stdin.isTTY) {
+                    cliError("Missing required argument: name", EXIT_MISUSE);
+                }
+                entryName = await promptName();
+            }
+            await handleCreateSingleOperation(module.module, collection, entryName, {
+                ...opts,
+            });
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+        }
+        catch (e) {
+            cliError(e.message || "An unexpected error occurred", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createDeleteCommand.js

@@ -0,0 +1,96 @@
+import { Argument } from "commander";
+import chalk from "chalk";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { handleDeleteSingleOperation } from "../operations/handleDeleteSingleOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+export function createDeleteCommand(program) {
+    program
+        .command("delete")
+        .alias("rm")
+        .description("Delete one or more entries from a collection")
+        .addHelpText("after", `
+Examples:
+  ay delete contacts 64a1b2c3d4e5                    Delete a single contact
+  ay rm contacts 64a1b2c3d4e5 --force                Skip confirmation
+  ay delete contacts id1,id2,id3                      Delete multiple entries
+  echo "id1,id2" | ay delete contacts --ids-stdin     Read IDs from stdin`)
+        .addArgument(new Argument("[collection]", "The collection to use").default(localStorage.getItem("lastCollection"), `The last used collection (${localStorage.getItem("lastCollection")})`))
+        .addArgument(new Argument("[ids]", "Comma-separated ID(s) to delete").default(localStorage.getItem("lastId"), `The last used id (${localStorage.getItem("lastId")})`))
+        .option("--ids-stdin", "Read IDs from stdin (one per line or comma-separated)")
+        .action(async (collection, ids, options) => {
+        try {
+            if (!collection) {
+                cliError("Missing required argument: collection. Run a list or get command first, or provide it explicitly.", EXIT_MISUSE);
+            }
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            // Collect IDs from argument and/or stdin
+            let idList = [];
+            if (ids) {
+                idList = ids.split(",").map((id) => id.trim()).filter(Boolean);
+            }
+            if (opts.idsStdin && !process.stdin.isTTY) {
+                const chunks = [];
+                for await (const chunk of process.stdin) {
+                    chunks.push(chunk);
+                }
+                const stdinContent = Buffer.concat(chunks).toString("utf-8").trim();
+                if (stdinContent) {
+                    const stdinIds = stdinContent
+                        .split(/[,\n]/)
+                        .map((id) => id.trim())
+                        .filter(Boolean);
+                    idList.push(...stdinIds);
+                }
+            }
+            if (idList.length === 0) {
+                cliError("No IDs provided. Pass IDs as argument or via --ids-stdin.", EXIT_MISUSE);
+            }
+            // Confirmation prompt (unless --force)
+            if (!opts.force && process.stdin.isTTY) {
+                const inquirer = (await import("inquirer")).default;
+                const { confirmed } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "confirmed",
+                        message: `Delete ${idList.length} entry/entries from ${collection}?`,
+                        default: false,
+                    },
+                ]);
+                if (!confirmed) {
+                    spinner.stop();
+                    console.error(chalk.yellow("  Aborted."));
+                    return;
+                }
+            }
+            // Execute deletions
+            let successCount = 0;
+            let errorCount = 0;
+            for (const id of idList) {
+                try {
+                    await handleDeleteSingleOperation(module.module, collection, id, opts);
+                    successCount++;
+                }
+                catch (e) {
+                    errorCount++;
+                    spinner.error({ text: `Failed to delete ${id}: ${e.message}` });
+                }
+            }
+            if (idList.length > 1) {
+                spinner.success({ text: `Deleted ${successCount}/${idList.length} entries from ${collection}` });
+                spinner.stop();
+            }
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+            if (errorCount > 0) {
+                process.exit(EXIT_GENERAL_ERROR);
+            }
+        }
+        catch (e) {
+            cliError(e.message || "An unexpected error occurred", EXIT_GENERAL_ERROR);
+        }
+    });
+}