product-discovery-cli 0.0.1

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "product-discovery-cli",
+  "version": "0.0.1",
+  "description": "CLI to consume the Product Discovery Agent API",
+  "license": "Apache-2.0",
+  "author": "AuronForge",
+  "keywords": [
+    "product-discovery",
+    "ai-agent",
+    "copilot",
+    "cli"
+  ],
+  "bin": {
+    "product-discovery": "src/index.js"
+  },
+  "files": [
+    "src",
+    "package.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "postinstall": "npm cache verify"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "boxen": "^5.1.2",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "inquirer": "^8.2.6",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  }
+}

package/src/application/RunDiscoveryFlow.js

@@ -0,0 +1,82 @@
+const { DiscoverySession } = require("../domain/DiscoverySession");
+
+class RunDiscoveryFlow {
+  constructor({ prompt, apiClient, storage, presenter }) {
+    this.prompt = prompt;
+    this.apiClient = apiClient;
+    this.storage = storage;
+    this.presenter = presenter;
+  }
+
+  async execute({ apiUrl, saveDefaults }) {
+    this.presenter.printHeader();
+
+    let continueOuter = true;
+
+    while (continueOuter) {
+      const session = new DiscoverySession();
+      let shouldImprove = true;
+
+      while (shouldImprove) {
+        this.presenter.info("What do you want to run discovery for?");
+        const idea = await this.prompt.askInput("Describe your idea/problem/application/pain:", {
+          required: true
+        });
+
+        const attemptText = session.addIdea(idea);
+
+        const spinner = this.presenter.spinner("Calling the discovery API...");
+        let result;
+        try {
+          result = await this.apiClient.runDiscovery(attemptText, apiUrl);
+          spinner.succeed("Discovery completed.");
+        } catch (error) {
+          spinner.fail("Discovery failed.");
+          this.presenter.error(error.message);
+          const retry = await this.prompt.askYesNo("Do you want to try again?");
+          if (!retry) {
+            return;
+          }
+          continue;
+        }
+
+        this.presenter.json(result);
+
+        if (saveDefaults.autoSave === false) {
+          const improve = await this.prompt.askYesNo("Do you want to improve the result?");
+          if (!improve) {
+            shouldImprove = false;
+            continueOuter = false;
+            break;
+          }
+          continue;
+        }
+
+        const saveInfo = await this.storage.saveJson(result, saveDefaults);
+        if (saveInfo.saved) {
+          this.presenter.success(`Saved to: ${saveInfo.fullPath}`);
+          shouldImprove = false;
+          continue;
+        }
+
+        const improve = await this.prompt.askYesNo("Do you want to improve the result?");
+        if (!improve) {
+          shouldImprove = false;
+          continueOuter = false;
+          break;
+        }
+      }
+
+      if (!continueOuter) {
+        break;
+      }
+
+      const another = await this.prompt.askYesNo("Do you want to run discovery for another idea?");
+      if (!another) {
+        continueOuter = false;
+      }
+    }
+  }
+}
+
+module.exports = { RunDiscoveryFlow };

package/src/config/cliOptions.js

@@ -0,0 +1,19 @@
+const { Command } = require("commander");
+
+function buildOptions(defaultApiUrl) {
+  const program = new Command();
+  program
+    .name("product-discovery")
+    .description("Generate a structured product discovery using the Product Discovery Agent API")
+    .option("-u, --api-url <url>", "API URL", defaultApiUrl)
+    .option("-c, --config <path>", "Path to JSON config file")
+    .option("-s, --save", "Auto-save the JSON result without prompting")
+    .option("-o, --output <dir>", "Default output directory")
+    .option("-f, --file <name>", "Default output filename")
+    .option("--no-save", "Disable saving prompt");
+
+  program.parse(process.argv);
+  return program.opts();
+}
+
+module.exports = { buildOptions };

package/src/domain/DiscoverySession.js

@@ -0,0 +1,15 @@
+class DiscoverySession {
+  constructor() {
+    this.baseIdea = "";
+  }
+
+  addIdea(text) {
+    if (!this.baseIdea) {
+      this.baseIdea = text;
+      return this.baseIdea;
+    }
+    return `${this.baseIdea}\n\nAdditional details: ${text}`;
+  }
+}
+
+module.exports = { DiscoverySession };

package/src/domain/PathNaming.js

@@ -0,0 +1,22 @@
+function sanitizeForFolderName(value) {
+  return (
+    value
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/gi, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 60) || "product"
+  );
+}
+
+function timestampForPath() {
+  return new Date().toISOString().replace(/[:.]/g, "-");
+}
+
+function ensureJsonExtension(filename) {
+  if (!filename.toLowerCase().endsWith(".json")) {
+    return `${filename}.json`;
+  }
+  return filename;
+}
+
+module.exports = { sanitizeForFolderName, timestampForPath, ensureJsonExtension };

package/src/index.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+const { CliController } = require("./presentation/CliController");
+const { PromptService } = require("./infrastructure/PromptService");
+const { ConsolePresenter } = require("./infrastructure/ConsolePresenter");
+const { ProductDiscoveryApi } = require("./infrastructure/ProductDiscoveryApi");
+const { JsonFileStorage } = require("./infrastructure/JsonFileStorage");
+const { RunDiscoveryFlow } = require("./application/RunDiscoveryFlow");
+
+const DEFAULT_API_URL = process.env.API_URL || "http://localhost:3000/api/v1/discovery";
+
+const prompt = new PromptService();
+const presenter = new ConsolePresenter();
+const apiClient = new ProductDiscoveryApi();
+const storage = new JsonFileStorage();
+const useCase = new RunDiscoveryFlow({ prompt, apiClient, storage, presenter });
+
+const controller = new CliController({
+  defaultApiUrl: DEFAULT_API_URL,
+  prompt,
+  presenter,
+  apiClient,
+  storage,
+  useCase
+});
+
+controller.start().catch((error) => {
+  presenter.error(`Unexpected error: ${error.message}`);
+});

package/src/infrastructure/ConfigLoader.js

@@ -0,0 +1,24 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+class ConfigLoader {
+  load(configPath) {
+    if (!configPath) return {};
+    const absolutePath = path.isAbsolute(configPath)
+      ? configPath
+      : path.join(process.cwd(), configPath);
+
+    if (!fs.existsSync(absolutePath)) {
+      throw new Error(`Config file not found: ${absolutePath}`);
+    }
+
+    const raw = fs.readFileSync(absolutePath, "utf-8");
+    try {
+      return JSON.parse(raw);
+    } catch (error) {
+      throw new Error(`Invalid JSON in config file: ${error.message}`);
+    }
+  }
+}
+
+module.exports = { ConfigLoader };

package/src/infrastructure/ConsolePresenter.js

@@ -0,0 +1,53 @@
+const { stdout: output } = require("node:process");
+const chalk = require("chalk");
+const boxen = require("boxen");
+const ora = require("ora");
+
+class ConsolePresenter {
+  printHeader() {
+    const logo = chalk.cyan(
+      String.raw`
+ ____                _            _     ____  _                               
+|  _ \ _ __ ___   __| |_   _  ___| |_  |  _ \(_)___  ___ _____   _____ _ __ 
+| |_) | '__/ _ \ / _ | | | |/ __| __| | | | | / __|/ __/ _ \ \ / / _ \ '__|
+|  __/| | | (_) | (_| | |_| | (__| |_  | |_| | \__ \ (_| (_) \ V /  __/ |   
+|_|   |_|  \___/ \__,_|\__,_|\___|\__| |____/|_|___/\___\___/ \_/ \___|_|   
+`
+    );
+    const title = chalk.bold.cyan("Product Discovery CLI");
+    const subtitle = chalk.gray("Generate a structured product discovery via the Product Discovery Agent API.");
+    const banner = `${logo}\n${title}\n${subtitle}`;
+    output.write(
+      boxen(banner, {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "cyan"
+      })
+    );
+    output.write("\n");
+  }
+
+  info(message) {
+    output.write(`${chalk.bold(message)}\n`);
+  }
+
+  success(message) {
+    output.write(`${chalk.green(message)}\n\n`);
+  }
+
+  error(message) {
+    output.write(`${chalk.red("Error:")} ${message}\n\n`);
+  }
+
+  json(payload) {
+    output.write(`\n${chalk.bold("Generated discovery JSON:")}\n\n`);
+    output.write(`${chalk.gray(JSON.stringify(payload, null, 2))}\n\n`);
+  }
+
+  spinner(text) {
+    return ora(text).start();
+  }
+}
+
+module.exports = { ConsolePresenter };

package/src/infrastructure/JsonFileStorage.js

@@ -0,0 +1,63 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const { sanitizeForFolderName, timestampForPath, ensureJsonExtension } = require("../domain/PathNaming");
+
+class JsonFileStorage {
+  resolveDesktopPath() {
+    const home = os.homedir();
+    const desktop = path.join(home, "Desktop");
+    if (fs.existsSync(desktop)) return desktop;
+    return home;
+  }
+
+  resolveSaveTarget({ result, directoryInput, filenameInput, defaultDir, defaultFileName }) {
+    const productName = sanitizeForFolderName(result?.name || "product");
+    const defaultFolderName = `product-${productName}-${timestampForPath()}`;
+
+    let targetDir = "";
+    let targetFilename = "";
+
+    if (!directoryInput && !filenameInput) {
+      const baseDir = defaultDir || this.resolveDesktopPath();
+      targetDir = path.join(baseDir, defaultFolderName);
+      targetFilename = defaultFileName || "discovery.json";
+    } else if (directoryInput && !filenameInput) {
+      targetDir = path.join(directoryInput, defaultFolderName);
+      targetFilename = defaultFileName || "discovery.json";
+    } else if (!directoryInput && filenameInput) {
+      targetDir = defaultDir || this.resolveDesktopPath();
+      targetFilename = filenameInput;
+    } else {
+      targetDir = directoryInput;
+      targetFilename = filenameInput;
+    }
+
+    targetFilename = ensureJsonExtension(targetFilename);
+    return { targetDir, targetFilename };
+  }
+
+  async saveJson(result, options) {
+    const wantsSave = options.autoSave ?? (await options.prompt.askYesNo("Do you want to save the JSON file?"));
+    if (!wantsSave) return { saved: false };
+
+    const directoryInput = options.directory ?? (await options.prompt.askInput("Directory (optional, press Enter to skip):"));
+    const filenameInput = options.filename ?? (await options.prompt.askInput("Filename (optional, press Enter to skip):"));
+
+    const { targetDir, targetFilename } = this.resolveSaveTarget({
+      result,
+      directoryInput,
+      filenameInput,
+      defaultDir: options.defaultDir,
+      defaultFileName: options.defaultFileName
+    });
+
+    fs.mkdirSync(targetDir, { recursive: true });
+    const fullPath = path.join(targetDir, targetFilename);
+
+    fs.writeFileSync(fullPath, JSON.stringify(result, null, 2), "utf-8");
+    return { saved: true, fullPath };
+  }
+}
+
+module.exports = { JsonFileStorage };

package/src/infrastructure/ProductDiscoveryApi.js

@@ -0,0 +1,26 @@
+class ProductDiscoveryApi {
+  async runDiscovery(problemText, apiUrl) {
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ problem: problemText })
+    });
+
+    const text = await response.text();
+    let payload = null;
+    try {
+      payload = text ? JSON.parse(text) : null;
+    } catch {
+      payload = text;
+    }
+
+    if (!response.ok) {
+      const message = payload?.message || response.statusText || "Unknown error";
+      throw new Error(`API error (${response.status}): ${message}`);
+    }
+
+    return payload;
+  }
+}
+
+module.exports = { ProductDiscoveryApi };

package/src/infrastructure/PromptService.js

@@ -0,0 +1,31 @@
+const inquirer = require("inquirer");
+
+class PromptService {
+  async askYesNo(message) {
+    const { answer } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "answer",
+        message,
+        default: false
+      }
+    ]);
+    return answer;
+  }
+
+  async askInput(message, { required = false } = {}) {
+    const { answer } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "answer",
+        message,
+        validate: required
+          ? (value) => (value && value.trim() ? true : "This field is required.")
+          : () => true
+      }
+    ]);
+    return answer.trim();
+  }
+}
+
+module.exports = { PromptService };

package/src/presentation/CliController.js

@@ -0,0 +1,38 @@
+const { buildOptions } = require("../config/cliOptions");
+const { ConfigLoader } = require("../infrastructure/ConfigLoader");
+
+class CliController {
+  constructor({ defaultApiUrl, prompt, presenter, apiClient, storage, useCase }) {
+    this.defaultApiUrl = defaultApiUrl;
+    this.prompt = prompt;
+    this.presenter = presenter;
+    this.apiClient = apiClient;
+    this.storage = storage;
+    this.useCase = useCase;
+  }
+
+  async start() {
+    const cliOptions = buildOptions(this.defaultApiUrl);
+    let config = {};
+    try {
+      config = new ConfigLoader().load(cliOptions.config);
+    } catch (error) {
+      this.presenter.error(`Config error: ${error.message}`);
+      return;
+    }
+
+    const apiUrl = cliOptions.apiUrl || config.apiUrl || process.env.PRODUCT_DISCOVERY_API_URL || this.defaultApiUrl;
+    const saveDefaults = {
+      autoSave: typeof cliOptions.save === "boolean" ? cliOptions.save : config.autoSave,
+      directory: cliOptions.output || config.defaultOutputDir,
+      filename: cliOptions.file || config.defaultFileName,
+      defaultDir: cliOptions.output || config.defaultOutputDir,
+      defaultFileName: cliOptions.file || config.defaultFileName,
+      prompt: this.prompt
+    };
+
+    await this.useCase.execute({ apiUrl, saveDefaults });
+  }
+}
+
+module.exports = { CliController };