@tolinax/ayoune-cli 2026.8.2 → 2026.10.0

package/lib/commands/aggregate/wizard.js

@@ -0,0 +1,174 @@
+// `ay aggregate wizard` — interactive pipeline builder.
+//
+// 5-step flow:
+//   1. List + select target model
+//   2. Fetch + display fields for that model (preview)
+//   3. Loop: pick stage type → run the stage builder → append to pipeline
+//      until the user picks "Done"
+//   4. Run a 5-row preview of the assembled pipeline so the user sees real
+//      output before committing
+//   5. Choose: execute / save / both / print / cancel
+//
+// The stage-builder helpers are in `_stageBuilders.ts` so this file stays
+// focused on the orchestration. Wizard requires a TTY — exits with EXIT_MISUSE
+// otherwise.
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+import { initializeSettings } from "../../helpers/initializeSettings.js";
+import { wrapAggResult } from "./_shared.js";
+import { buildStage } from "./_stageBuilders.js";
+export function addWizardSubcommand(agg, rootProgram) {
+    agg
+        .command("wizard")
+        .alias("wiz")
+        .description("Interactive pipeline builder wizard")
+        .action(async (options) => {
+        var _a, _b, _c, _d, _e;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            if (!process.stdin.isTTY) {
+                cliError("Wizard requires an interactive terminal (TTY)", EXIT_MISUSE);
+            }
+            // Step 1: Select model
+            initializeSettings();
+            spinner.start({ text: "Loading models...", color: "magenta" });
+            const modelsRes = await apiCallHandler("aggregation", "models", "get");
+            spinner.stop();
+            const modelChoices = (modelsRes.payload || []).map((m) => ({
+                name: `${m.name} ${chalk.dim(`(${m.module})`)}`,
+                value: m.name,
+            }));
+            const { selectedModel } = await inquirer.prompt([
+                {
+                    type: "search-list",
+                    name: "selectedModel",
+                    message: "Select a model:",
+                    choices: modelChoices,
+                },
+            ]);
+            // Step 2: Fetch and display fields
+            spinner.start({ text: `Loading fields for ${selectedModel}...`, color: "magenta" });
+            const fieldsRes = await apiCallHandler("aggregation", `models/${selectedModel}/fields`, "get");
+            spinner.stop();
+            const fields = ((_a = fieldsRes.payload) === null || _a === void 0 ? void 0 : _a.fields) || [];
+            const fieldNames = fields.map((f) => f.field);
+            console.log(chalk.cyan(`\n  Fields for ${selectedModel}:\n`));
+            for (const f of fields) {
+                const ref = f.ref ? chalk.dim(` -> ${f.ref}`) : "";
+                const req = f.required ? chalk.yellow(" *") : "";
+                console.log(`    ${chalk.white(f.field)} ${chalk.dim(`(${f.type})`)}${ref}${req}`);
+            }
+            console.log();
+            // Step 3: Build stages iteratively
+            const pipeline = [];
+            let addMore = true;
+            while (addMore) {
+                const { stageType } = await inquirer.prompt([
+                    {
+                        type: "list",
+                        name: "stageType",
+                        message: `Add stage ${pipeline.length + 1}:`,
+                        choices: [
+                            { name: "$match — Filter documents", value: "$match" },
+                            { name: "$group — Group and aggregate", value: "$group" },
+                            { name: "$sort — Sort results", value: "$sort" },
+                            { name: "$project — Include/exclude fields", value: "$project" },
+                            { name: "$unwind — Deconstruct array field", value: "$unwind" },
+                            { name: "$lookup — Join with another collection", value: "$lookup" },
+                            { name: "$limit — Limit results", value: "$limit" },
+                            { name: "$skip — Skip results", value: "$skip" },
+                            { name: "$count — Count documents", value: "$count" },
+                            { name: "$addFields — Add computed fields", value: "$addFields" },
+                            new inquirer.Separator(),
+                            { name: "Raw JSON stage", value: "$raw" },
+                            new inquirer.Separator(),
+                            { name: chalk.green("Done — preview and execute"), value: "$done" },
+                        ],
+                    },
+                ]);
+                if (stageType === "$done") {
+                    addMore = false;
+                    break;
+                }
+                const stage = await buildStage(stageType, fieldNames, fields);
+                if (stage) {
+                    pipeline.push(stage);
+                    console.log(chalk.dim(`  Added: ${JSON.stringify(stage)}\n`));
+                }
+            }
+            if (pipeline.length === 0) {
+                cliError("Pipeline is empty — add at least one stage", EXIT_MISUSE);
+            }
+            // Step 4: Preview
+            console.log(chalk.cyan("\n  Pipeline:\n"));
+            console.log(chalk.dim("  " + JSON.stringify(pipeline, null, 2).split("\n").join("\n  ")));
+            console.log();
+            spinner.start({ text: "Running preview (first 5 results)...", color: "magenta" });
+            const previewPipeline = [...pipeline, { $limit: 5 }];
+            const previewRes = await apiCallHandler("aggregation", selectedModel, "post", previewPipeline);
+            spinner.stop();
+            const previewWrapped = wrapAggResult(previewRes);
+            handleResponseFormatOptions({ ...opts, responseFormat: "yaml" }, previewWrapped);
+            // Step 5: Action choice
+            const { action } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "action",
+                    message: "What would you like to do?",
+                    choices: [
+                        { name: "Execute full pipeline", value: "execute" },
+                        { name: "Save as reusable query", value: "save" },
+                        { name: "Execute and save", value: "both" },
+                        { name: "Print pipeline JSON", value: "print" },
+                        { name: "Cancel", value: "cancel" },
+                    ],
+                },
+            ]);
+            if (action === "execute" || action === "both") {
+                spinner.start({ text: "Executing full pipeline...", color: "magenta" });
+                const res = await apiCallHandler("aggregation", selectedModel, "post", pipeline);
+                const wrapped = wrapAggResult(res);
+                handleResponseFormatOptions(opts, wrapped);
+                spinner.success({
+                    text: `Pipeline returned ${(_c = (_b = wrapped.meta) === null || _b === void 0 ? void 0 : _b.resultCount) !== null && _c !== void 0 ? _c : "?"} results`,
+                });
+            }
+            if (action === "save" || action === "both") {
+                const { queryName } = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "queryName",
+                        message: "Query name:",
+                        validate: (v) => v.length > 0 || "Name is required",
+                    },
+                ]);
+                spinner.start({ text: "Saving query...", color: "magenta" });
+                const body = {
+                    name: queryName,
+                    dataSource: {
+                        source: "aggregation",
+                        aggregationModel: selectedModel,
+                        aggregationPipeline: JSON.stringify(pipeline),
+                    },
+                    cache: { enabled: false },
+                };
+                const saveRes = await apiCallHandler("config", "queries", "post", body, {
+                    responseFormat: "json",
+                });
+                const slug = ((_d = saveRes.payload) === null || _d === void 0 ? void 0 : _d.slug) || ((_e = saveRes.payload) === null || _e === void 0 ? void 0 : _e.name) || queryName;
+                spinner.success({ text: `Query saved — run with: ay agg exec ${slug}` });
+            }
+            if (action === "print") {
+                console.log(JSON.stringify(pipeline, null, 2));
+            }
+        }
+        catch (e) {
+            cliError(e.message || "Wizard failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}