product-discovery-cli 0.0.13 → 0.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "product-discovery-cli",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "CLI to consume the Product Discovery Agent API",
   "license": "Apache-2.0",
   "author": "AuronForge",
@@ -31,6 +31,7 @@
   },
   "dependencies": {
     "boxen": "^5.1.2",
+    "cfonts": "^3.3.1",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "inquirer": "^8.2.6",

package/src/application/RunDiscoveryFlow.js

@@ -10,7 +10,7 @@ class RunDiscoveryFlow {
 
   async execute({ apiUrl, lang, saveDefaults, i18n }) {
     this.i18n = i18n;
-    this.presenter.printHeader();
+    this.presenter.printHeader(apiUrl);
 
     let continueOuter = true;
 

package/src/application/RunDiscoveryFlow.spec.js

@@ -0,0 +1,222 @@
+const { RunDiscoveryFlow } = require("./RunDiscoveryFlow");
+
+const mockI18n = {
+  t: jest.fn((key) => key)
+};
+
+describe("RunDiscoveryFlow", () => {
+  test("runs discovery, saves, and stops", async () => {
+    const prompt = {
+      askInput: jest.fn().mockResolvedValue("My idea"),
+      askYesNo: jest.fn().mockResolvedValue(false)
+    };
+    const presenter = {
+      printHeader: jest.fn(),
+      info: jest.fn(),
+      error: jest.fn(),
+      json: jest.fn(),
+      success: jest.fn(),
+      goodbye: jest.fn(),
+      spinner: jest.fn().mockReturnValue({ succeed: jest.fn(), fail: jest.fn() })
+    };
+    const apiClient = {
+      runDiscovery: jest.fn().mockResolvedValue({ name: "Test Product" })
+    };
+    const storage = {
+      saveJson: jest.fn().mockResolvedValue({ saved: true, fullPath: "/tmp/file.json" })
+    };
+
+    const useCase = new RunDiscoveryFlow({ prompt, apiClient, storage, presenter });
+    await useCase.execute({
+      apiUrl: "http://localhost/api",
+      lang: "pt-br",
+      saveDefaults: { autoSave: true },
+      i18n: mockI18n
+    });
+
+    expect(presenter.printHeader).toHaveBeenCalled();
+    expect(prompt.askInput).toHaveBeenCalled();
+    expect(apiClient.runDiscovery).toHaveBeenCalledWith("My idea", "http://localhost/api", "pt-br");
+    expect(storage.saveJson).toHaveBeenCalled();
+    expect(presenter.goodbye).toHaveBeenCalled();
+  });
+
+  test("asks to improve when not saving and exits on no", async () => {
+    const prompt = {
+      askInput: jest.fn().mockResolvedValue("My idea"),
+      askYesNo: jest.fn().mockResolvedValueOnce(false)
+    };
+    const presenter = {
+      printHeader: jest.fn(),
+      info: jest.fn(),
+      error: jest.fn(),
+      json: jest.fn(),
+      success: jest.fn(),
+      goodbye: jest.fn(),
+      spinner: jest.fn().mockReturnValue({ succeed: jest.fn(), fail: jest.fn() })
+    };
+    const apiClient = {
+      runDiscovery: jest.fn().mockResolvedValue({ name: "Test Product" })
+    };
+    const storage = {
+      saveJson: jest.fn()
+    };
+
+    const useCase = new RunDiscoveryFlow({ prompt, apiClient, storage, presenter });
+    await useCase.execute({
+      apiUrl: "http://localhost/api",
+      lang: "pt-br",
+      saveDefaults: { autoSave: false },
+      i18n: mockI18n
+    });
+
+    expect(prompt.askYesNo).toHaveBeenCalledWith("askImprove");
+    expect(storage.saveJson).not.toHaveBeenCalled();
+    expect(presenter.goodbye).toHaveBeenCalled();
+  });
+
+  test("retries when discovery fails and user chooses to retry", async () => {
+    const prompt = {
+      askInput: jest.fn().mockResolvedValue("My idea"),
+      askYesNo: jest
+        .fn()
+        .mockResolvedValueOnce(true)
+        .mockResolvedValueOnce(false)
+    };
+    const presenter = {
+      printHeader: jest.fn(),
+      info: jest.fn(),
+      error: jest.fn(),
+      json: jest.fn(),
+      success: jest.fn(),
+      goodbye: jest.fn(),
+      spinner: jest.fn().mockReturnValue({ succeed: jest.fn(), fail: jest.fn() })
+    };
+    const apiClient = {
+      runDiscovery: jest
+        .fn()
+        .mockRejectedValueOnce(new Error("API down"))
+        .mockResolvedValueOnce({ name: "Recovered" })
+    };
+    const storage = {
+      saveJson: jest.fn().mockResolvedValue({ saved: true, fullPath: "/tmp/file.json" })
+    };
+
+    const useCase = new RunDiscoveryFlow({ prompt, apiClient, storage, presenter });
+    await useCase.execute({
+      apiUrl: "http://localhost/api",
+      lang: "pt-br",
+      saveDefaults: { autoSave: true },
+      i18n: mockI18n
+    });
+
+    expect(apiClient.runDiscovery).toHaveBeenCalledTimes(2);
+    expect(presenter.error).toHaveBeenCalledWith("API down");
+    expect(presenter.goodbye).toHaveBeenCalled();
+  });
+
+  test("prompts to improve after save declined", async () => {
+    const prompt = {
+      askInput: jest.fn().mockResolvedValue("My idea"),
+      askYesNo: jest
+        .fn()
+        .mockResolvedValueOnce(true)
+        .mockResolvedValueOnce(false)
+    };
+    const presenter = {
+      printHeader: jest.fn(),
+      info: jest.fn(),
+      error: jest.fn(),
+      json: jest.fn(),
+      success: jest.fn(),
+      goodbye: jest.fn(),
+      spinner: jest.fn().mockReturnValue({ succeed: jest.fn(), fail: jest.fn() })
+    };
+    const apiClient = {
+      runDiscovery: jest.fn().mockResolvedValue({ name: "Test Product" })
+    };
+    const storage = {
+      saveJson: jest.fn().mockResolvedValue({ saved: false })
+    };
+
+    const useCase = new RunDiscoveryFlow({ prompt, apiClient, storage, presenter });
+    await useCase.execute({
+      apiUrl: "http://localhost/api",
+      lang: "pt-br",
+      saveDefaults: { autoSave: true },
+      i18n: mockI18n
+    });
+
+    expect(storage.saveJson).toHaveBeenCalled();
+    expect(prompt.askYesNo).toHaveBeenCalledWith("askImprove");
+    expect(presenter.goodbye).toHaveBeenCalled();
+  });
+
+  test("stops when discovery fails and user declines retry", async () => {
+    const prompt = {
+      askInput: jest.fn().mockResolvedValue("My idea"),
+      askYesNo: jest.fn().mockResolvedValue(false)
+    };
+    const presenter = {
+      printHeader: jest.fn(),
+      info: jest.fn(),
+      error: jest.fn(),
+      json: jest.fn(),
+      success: jest.fn(),
+      goodbye: jest.fn(),
+      spinner: jest.fn().mockReturnValue({ succeed: jest.fn(), fail: jest.fn() })
+    };
+    const apiClient = {
+      runDiscovery: jest.fn().mockRejectedValue(new Error("API down"))
+    };
+    const storage = {
+      saveJson: jest.fn()
+    };
+
+    const useCase = new RunDiscoveryFlow({ prompt, apiClient, storage, presenter });
+    await useCase.execute({
+      apiUrl: "http://localhost/api",
+      lang: "pt-br",
+      saveDefaults: { autoSave: true },
+      i18n: mockI18n
+    });
+
+    expect(prompt.askYesNo).toHaveBeenCalledWith("askRetry");
+    expect(storage.saveJson).not.toHaveBeenCalled();
+    expect(presenter.goodbye).toHaveBeenCalled();
+  });
+
+  test("continues when autoSave false and user wants to improve", async () => {
+    const prompt = {
+      askInput: jest.fn().mockResolvedValue("My idea"),
+      askYesNo: jest.fn().mockResolvedValueOnce(true).mockResolvedValueOnce(false)
+    };
+    const presenter = {
+      printHeader: jest.fn(),
+      info: jest.fn(),
+      error: jest.fn(),
+      json: jest.fn(),
+      success: jest.fn(),
+      goodbye: jest.fn(),
+      spinner: jest.fn().mockReturnValue({ succeed: jest.fn(), fail: jest.fn() })
+    };
+    const apiClient = {
+      runDiscovery: jest.fn().mockResolvedValue({ name: "Test Product" })
+    };
+    const storage = {
+      saveJson: jest.fn()
+    };
+
+    const useCase = new RunDiscoveryFlow({ prompt, apiClient, storage, presenter });
+    await useCase.execute({
+      apiUrl: "http://localhost/api",
+      lang: "pt-br",
+      saveDefaults: { autoSave: false },
+      i18n: mockI18n
+    });
+
+    expect(apiClient.runDiscovery).toHaveBeenCalledTimes(2);
+    expect(prompt.askYesNo).toHaveBeenCalledWith("askImprove");
+    expect(presenter.goodbye).toHaveBeenCalled();
+  });
+});

package/src/domain/DiscoverySession.spec.js

@@ -0,0 +1,12 @@
+const { DiscoverySession } = require("./DiscoverySession");
+
+describe("DiscoverySession", () => {
+  test("appends additional details after base idea", () => {
+    const session = new DiscoverySession();
+    const first = session.addIdea("Base idea");
+    const second = session.addIdea("More details");
+
+    expect(first).toBe("Base idea");
+    expect(second).toBe("Base idea\n\nAdditional details: More details");
+  });
+});

package/src/domain/PathNaming.spec.js

@@ -0,0 +1,26 @@
+const {
+  sanitizeForFolderName,
+  timestampForPath,
+  ensureJsonExtension
+} = require("./PathNaming");
+
+describe("PathNaming", () => {
+  test("sanitizeForFolderName normalizes input", () => {
+    expect(sanitizeForFolderName("My Product!! 2024")).toBe("my-product-2024");
+  });
+
+  test("sanitizeForFolderName falls back to product", () => {
+    expect(sanitizeForFolderName("###")).toBe("product");
+  });
+
+  test("timestampForPath returns a safe string", () => {
+    const value = timestampForPath();
+    expect(value).toMatch(/\d{4}-\d{2}-\d{2}T/);
+    expect(value).not.toMatch(/[:.]/);
+  });
+
+  test("ensureJsonExtension appends extension", () => {
+    expect(ensureJsonExtension("discovery")).toBe("discovery.json");
+    expect(ensureJsonExtension("report.JSON")).toBe("report.JSON");
+  });
+});

package/src/infrastructure/ConsolePresenter.js

@@ -2,6 +2,7 @@ const { stdout: output } = require("node:process");
 const chalk = require("chalk");
 const boxen = require("boxen");
 const ora = require("ora");
+const cfonts = require("cfonts");
 const pkg = require("../../package.json");
 
 class ConsolePresenter {
@@ -9,23 +10,36 @@ class ConsolePresenter {
     this.i18n = i18n;
   }
 
-  printHeader() {
+  printHeader(apiUrl = null) {
     if (!this.i18n) return;
-    const logo = chalk.cyan(
-      String.raw`
- ____                _            _     ____  _                               
-|  _ \ _ __ ___   __| |_   _  ___| |_  |  _ \(_)___  ___ _____   _____ _ __ 
-| |_) | '__/ _ \ / _ | | | |/ __| __| | | | | / __|/ __/ _ \ \ / / _ \ '__|
-|  __/| | | (_) | (_| | |_| | (__| |_  | |_| | \__ \ (_| (_) \ V /  __/ |   
-|_|   |_|  \___/ \__,_|\__,_|\___|\__| |____/|_|___/\___\___/ \_/ \___|_|   
-`
-    );
+    const logo = cfonts.render("product discovery", {
+      font: "chrome",
+      align: "left",
+      colors: ["cyan"],
+      background: "transparent",
+      letterSpacing: 1,
+      lineHeight: 1,
+      space: false,
+      maxLength: 0
+    }).string;
     const title = chalk.bold.cyan(this.i18n.t("headerTitle"));
     const subtitle = chalk.gray(this.i18n.t("headerSubtitle"));
     const author = chalk.gray(`${this.i18n.t("headerAuthor")}: ${pkg.author}`);
     const version = chalk.gray(`${this.i18n.t("headerVersion")}: ${pkg.version}`);
     const license = chalk.gray(`${this.i18n.t("headerLicense")}: ${pkg.license}`);
-    const banner = `${logo}\n${title}\n${subtitle}\n\n${author}\n${version}\n${license}`;
+
+    let portLine = "";
+    if (apiUrl && apiUrl.includes("localhost")) {
+      try {
+        const url = new URL(apiUrl);
+        const port = url.port || (url.protocol === "https:" ? 443 : 80);
+        portLine = `\n${chalk.cyan(`🔌 ${this.i18n.t("runningOnPort")} ${port}`)}`;
+      } catch (error) {
+        // Ignora se falhar ao parsear
+      }
+    }
+
+    const banner = `${logo}\n${title}\n${subtitle}\n\n${author}\n${version}\n${license}${portLine}`;
     output.write(
       boxen(banner, {
         padding: 1,

package/src/infrastructure/i18n.js

@@ -19,6 +19,7 @@ const translations = {
     
     // ConsolePresenter
     generatedDiscovery: "Discovery JSON gerado:",
+    runningOnPort: "Rodando na porta",
     error: "Erro:",
     
     // RunDiscoveryFlow
@@ -63,6 +64,7 @@ const translations = {
     
     // ConsolePresenter
     generatedDiscovery: "Generated discovery JSON:",
+    runningOnPort: "Running on port",
     error: "Error:",
     
     // RunDiscoveryFlow