prdforge-cli 0.1.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prdforge-cli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Official CLI for PRDForge — generate and manage PRDs from your terminal or AI agents",
   "main": "src/index.js",
   "bin": {
@@ -40,6 +40,7 @@
     "commander": "^12.1.0",
     "conf": "^13.0.0",
     "dotenv": "^16.4.5",
+    "figlet": "^1.11.0",
     "ink": "^5.2.1",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",

package/src/api/client.js

@@ -1,4 +1,5 @@
 import { getApiUrl, requireApiKey } from "../utils/config.js";
+import { debugLog } from "../utils/debug.js";
 
 /** User-facing messages for HTTP status codes (centralized for CLI and agents). */
 function messageForStatus(status, bodyMessage) {
@@ -24,16 +25,25 @@ function messageForStatus(status, bodyMessage) {
  * Make an authenticated request to the PRDForge API (Supabase Edge Functions).
  * Throws an Error with user-facing message and .httpStatus for exit code handling.
  */
+export function buildHeaders(apiKey) {
+  return {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${apiKey}`,
+    "x-prdforge-cli": "1",
+  };
+}
+
 async function request(path, { method = "GET", body } = {}) {
   const apiKey = requireApiKey();
   const baseUrl = getApiUrl();
   const url = `${baseUrl}${path}`;
 
-  const headers = {
-    "Content-Type": "application/json",
-    "Authorization": `Bearer ${apiKey}`,
-    "x-prdforge-cli": "1",
-  };
+  const headers = buildHeaders(apiKey);
+
+  debugLog("request", { method, url });
+
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 30_000);
 
   let res;
   try {
@@ -41,13 +51,23 @@ async function request(path, { method = "GET", body } = {}) {
       method,
       headers,
       body: body ? JSON.stringify(body) : undefined,
+      signal: controller.signal,
     });
   } catch (e) {
-    const err = new Error("Could not reach PRDForge. Check your connection and API URL.");
+    const isTimeout = e.name === "AbortError";
+    const err = new Error(
+      isTimeout
+        ? "Request timed out. Check your connection and try again."
+        : "Could not reach PRDForge. Check your connection and API URL."
+    );
     err.httpStatus = 0;
     throw err;
+  } finally {
+    clearTimeout(timeoutId);
   }
 
+  debugLog("response", { status: res.status });
+
   if (!res.ok) {
     let bodyMessage;
     try {
@@ -131,10 +151,16 @@ export const exports_ = {
 // ─── Auth ────────────────────────────────────────────────────────────────────
 
 export const auth = {
-  validate: (apiKey) =>
-    fetch(`${getApiUrl()}/prdforge-api/auth/validate`, {
+  validate: (apiKey) => {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 30_000);
+    return fetch(`${getApiUrl()}/prdforge-api/auth/validate`, {
       headers: { Authorization: `Bearer ${apiKey}` },
-    }).then((r) => r.json()),
+      signal: controller.signal,
+    })
+      .then((r) => r.json())
+      .finally(() => clearTimeout(timeoutId));
+  },
 };
 
 // ─── User ────────────────────────────────────────────────────────────────────

package/src/api/stream.js

@@ -0,0 +1,97 @@
+import { buildHeaders } from "./client.js";
+import { getApiUrl, requireApiKey } from "../utils/config.js";
+import { debugLog } from "../utils/debug.js";
+
+/**
+ * Async generator that streams PRD AI events via SSE.
+ * Falls back to a single synthesized "done" event if the server returns JSON.
+ *
+ * @param {{ action: string, project_id?: string, prompt?: string, model_id?: string }} body
+ * @param {AbortSignal} [signal]
+ * @yields {{ event: string, data: object }}
+ */
+export async function* streamPrdAi(body, signal) {
+  const apiKey = requireApiKey();
+  const url = `${getApiUrl()}/prdforge-ai`;
+  debugLog("stream:request", { url, action: body.action });
+
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: { ...buildHeaders(apiKey), "Accept": "text/event-stream" },
+      body: JSON.stringify(body),
+      signal,
+    });
+  } catch (e) {
+    const isAbort = e.name === "AbortError";
+    if (isAbort) return; // clean cancellation
+    const err = new Error("Could not reach PRDForge. Check your connection and API URL.");
+    err.httpStatus = 0;
+    throw err;
+  }
+
+  // Fallback: server returned JSON (no SSE support yet)
+  if (!res.headers.get("content-type")?.includes("text/event-stream")) {
+    debugLog("stream:fallback", { status: res.status });
+    let json;
+    try { json = await res.json(); } catch { json = {}; }
+    if (!res.ok) {
+      const err = new Error(json.error ?? `Request failed (HTTP ${res.status}).`);
+      err.httpStatus = res.status;
+      throw err;
+    }
+    yield { event: "done", data: json };
+    return;
+  }
+
+  // SSE stream
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  try {
+    for await (const chunk of res.body) {
+      buffer += decoder.decode(chunk, { stream: true });
+      const blocks = buffer.split("\n\n");
+      buffer = blocks.pop(); // keep incomplete trailing block
+      for (const block of blocks) {
+        const parsed = parseSSEBlock(block);
+        if (parsed) {
+          debugLog("stream:event", { event: parsed.event });
+          yield parsed;
+          if (parsed.event === "done" || parsed.event === "error") return;
+        }
+      }
+    }
+  } catch (e) {
+    if (e.name === "AbortError") return;
+    throw e;
+  }
+
+  // Flush any remaining buffer after stream ends
+  if (buffer.trim()) {
+    const parsed = parseSSEBlock(buffer);
+    if (parsed) yield parsed;
+  }
+}
+
+/**
+ * Parse a single SSE block (lines separated by \n, blocks separated by \n\n).
+ * @param {string} block
+ * @returns {{ event: string, data: object | string } | null}
+ */
+function parseSSEBlock(block) {
+  let event = "message";
+  let data = null;
+
+  for (const line of block.split("\n")) {
+    if (line.startsWith("event: ")) {
+      event = line.slice(7).trim();
+    } else if (line.startsWith("data: ")) {
+      const raw = line.slice(6);
+      try { data = JSON.parse(raw); } catch { data = raw; }
+    }
+  }
+
+  return data !== null ? { event, data } : null;
+}

package/src/commands/auth.js

@@ -120,10 +120,141 @@ export function authCommand() {
       info("Run 'prdforge prd list' to see your projects.");
     });
 
+  cmd
+    .command("signup")
+    .description("Create a new PRDForge account")
+    .action(async () => {
+      const { default: inquirer } = await import("inquirer");
+      const { default: ora } = await import("ora");
+
+      const { email } = await inquirer.prompt([{
+        type: "input",
+        name: "email",
+        message: "Email address:",
+        validate: (v) => v.trim().includes("@") || "Enter a valid email",
+      }]);
+
+      const { firstName } = await inquirer.prompt([{
+        type: "input",
+        name: "firstName",
+        message: "First name (optional, press Enter to skip):",
+      }]);
+
+      const authBase = getAuthBase();
+      process.stdout.write("\n");
+      const spinner = ora("Creating your account…").start();
+
+      let sendRes, sendData;
+      try {
+        sendRes = await fetch(authBase, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            action: "signup",
+            email: email.trim().toLowerCase(),
+            ...(firstName.trim() ? { first_name: firstName.trim().slice(0, 50) } : {}),
+          }),
+        });
+        sendData = await sendRes.json().catch(() => ({}));
+      } catch {
+        spinner.fail("Network error — could not reach PRDForge.");
+        process.exit(1);
+      }
+
+      const errMsg = (sendData.error ?? "").toLowerCase();
+
+      if (!sendRes.ok && !errMsg.includes("already") && !errMsg.includes("exists")
+          && sendRes.status !== 404 && sendRes.status !== 405) {
+        spinner.fail(sendData.error ?? "Signup failed.");
+        process.exit(1);
+      }
+
+      if (errMsg.includes("already") || errMsg.includes("exists")) {
+        spinner.warn("Account already exists — sending a login code instead.");
+        try {
+          sendRes = await fetch(authBase, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ action: "request", email: email.trim().toLowerCase() }),
+          });
+          sendData = await sendRes.json().catch(() => ({}));
+        } catch {
+          error("Network error.");
+          process.exit(1);
+        }
+        if (!sendRes.ok || !sendData.success) {
+          error(sendData.error ?? "Failed to send code.");
+          process.exit(1);
+        }
+      } else if (sendRes.status === 404 || sendRes.status === 405) {
+        // No dedicated signup endpoint — fall back to OTP request silently
+        try {
+          sendRes = await fetch(authBase, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ action: "request", email: email.trim().toLowerCase() }),
+          });
+          sendData = await sendRes.json().catch(() => ({}));
+        } catch {
+          spinner.fail("Network error.");
+          process.exit(1);
+        }
+        if (!sendRes.ok || !sendData.success) {
+          spinner.fail(sendData.error ?? "Failed to send verification code.");
+          process.exit(1);
+        }
+      }
+
+      spinner.succeed("Verification code sent — check your email.");
+
+      const { code } = await inquirer.prompt([{
+        type: "input",
+        name: "code",
+        message: "Enter the 6-digit code:",
+        validate: (v) => /^\d{6}$/.test(v.trim()) || "Must be 6 digits",
+      }]);
+
+      const verSpinner = ora("Verifying…").start();
+      let verRes, verData;
+      try {
+        verRes = await fetch(authBase, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ action: "verify", email: email.trim().toLowerCase(), code: code.trim() }),
+        });
+        verData = await verRes.json().catch(() => ({}));
+      } catch {
+        verSpinner.fail("Network error.");
+        process.exit(1);
+      }
+
+      if (!verRes.ok || !verData.success) {
+        verSpinner.fail(verData.error ?? "Invalid or expired code.");
+        process.exit(1);
+      }
+
+      config.set("apiKey", verData.api_key);
+      setEmail(verData.email ?? email.trim().toLowerCase());
+      verSpinner.succeed(`Welcome to PRDForge! Signed in as ${verData.email ?? email}`);
+      dim("  Config: " + config.path);
+      info("Run 'prdforge prd list' or just 'prdforge' to get started.");
+    });
+
   cmd
     .command("logout")
     .description("Remove stored API key")
-    .action(() => {
+    .option("-f, --force", "Skip confirmation prompt")
+    .action(async (opts) => {
+      if (!opts.force) {
+        const { default: inquirer } = await import("inquirer");
+        const { confirmed } = await inquirer.prompt([{
+          type: "confirm",
+          name: "confirmed",
+          message: "Remove your stored API key?",
+          default: false,
+        }]);
+        if (!confirmed) { info("Logout cancelled."); return; }
+      }
       config.delete("apiKey");
       success("Logged out — API key removed.");
     });

package/src/commands/dashboard.js

@@ -1,7 +1,6 @@
 import { Command } from "commander";
 import React from "react";
 import { render } from "ink";
-import { Dashboard } from "../ui/Dashboard.js";
 import { requireApiKey } from "../utils/config.js";
 
 export function dashboardCommand() {
@@ -10,79 +9,8 @@ export function dashboardCommand() {
     .description("Open interactive project overview (keyboard navigable)")
     .action(async () => {
       requireApiKey();
-
-      let createArgs = null;
-
-      const { waitUntilExit } = render(
-        React.createElement(Dashboard, {
-          onCreateNew: (args) => { createArgs = args; },
-        })
-      );
-
+      const { REPLDashboard } = await import("../ui/REPLDashboard.js");
+      const { waitUntilExit } = render(React.createElement(REPLDashboard));
       await waitUntilExit();
-
-      // If user pressed Enter in compose mode, launch the prd create flow
-      if (createArgs) {
-        const { prdCommand } = await import("./prd.js");
-        const { projects, prd, isAuthError } = await import("../api/client.js");
-        const { success, error, info, dim } = await import("../utils/output.js");
-        const { default: ora } = await import("ora");
-        const { render: inkRender } = await import("ink");
-        const { PrdCreation, buildStages, setStageStatus, markAllDone } = await import("../ui/PrdCreation.js");
-        const { theme } = await import("../ui/theme.js");
-
-        // Prompt for project name
-        const { default: inquirer } = await import("inquirer");
-        const { projectName } = await inquirer.prompt([
-          {
-            type: "input",
-            name: "projectName",
-            message: "Project name:",
-            validate: (v) => v.trim().length > 0 || "Required",
-          },
-        ]);
-
-        const { prompt, modelId } = createArgs;
-
-        // Animated stage progress
-        let stages = buildStages(theme.stages);
-        stages = setStageStatus(stages, 0, "active");
-
-        const inkInstance = inkRender(
-          React.createElement(PrdCreation, { projectName: projectName.trim(), stages })
-        );
-
-        const STAGE_INTERVAL_MS = 8000;
-        let currentStage = 0;
-        const timer = setInterval(() => {
-          if (currentStage < theme.stages.length - 1) {
-            stages = setStageStatus(stages, currentStage, "done");
-            currentStage += 1;
-            stages = setStageStatus(stages, currentStage, "active");
-            inkInstance.rerender(
-              React.createElement(PrdCreation, { projectName: projectName.trim(), stages })
-            );
-          }
-        }, STAGE_INTERVAL_MS);
-
-        try {
-          const project = await projects.create(projectName.trim(), prompt);
-          const result = await prd.generate(project.id, prompt, modelId ?? undefined);
-          clearInterval(timer);
-          stages = markAllDone(stages);
-          inkInstance.rerender(
-            React.createElement(PrdCreation, { projectName: projectName.trim(), stages })
-          );
-          inkInstance.unmount();
-          success(`Project "${projectName.trim()}" created`);
-          dim(`  ID: ${project.id}`);
-          info(`View in browser: https://prdforge.netlify.app/workspace/${project.id}`);
-        } catch (err) {
-          clearInterval(timer);
-          inkInstance.unmount();
-          error(err.message);
-          process.exit(isAuthError(err) ? 2 : 1);
-        }
-      }
     });
 }

package/src/hooks/useScroll.js

@@ -0,0 +1,20 @@
+import { useState } from "react";
+
+/**
+ * Virtual windowing scroll hook.
+ * @param {number} totalItems - total number of items in the list
+ * @param {number} visibleRows - how many rows can be shown at once
+ */
+export function useScroll(totalItems, visibleRows) {
+  const [offset, setOffset] = useState(0);
+
+  const clamp = (o) => Math.min(Math.max(o, 0), Math.max(0, totalItems - visibleRows));
+
+  return {
+    offset,
+    scrollDown:   () => setOffset((o) => clamp(o + 1)),
+    scrollUp:     () => setOffset((o) => clamp(o - 1)),
+    jumpToBottom: () => setOffset(clamp(totalItems)),
+    reset:        () => setOffset(0),
+  };
+}

package/src/hooks/useStream.js

@@ -0,0 +1,144 @@
+import { useState, useRef, useCallback, useEffect } from "react";
+import { streamPrdAi } from "../api/stream.js";
+import { theme } from "../ui/theme.js";
+
+/**
+ * Manages SSE streaming state for PRD generation and updates.
+ *
+ * Returns:
+ *   stages       — [{label, status, preview}] for StageIndicator rendering
+ *   messages     — [{id, role, text, status}] for ReplPanel history
+ *   setMessages  — direct setter (for adding user messages)
+ *   isStreaming  — bool
+ *   error        — string | null
+ *   startStream  — (body, options?) => void  begins stream
+ *   abort        — () => void  cancels current stream
+ */
+export function useStream() {
+  const [stages, setStages]       = useState([]);
+  const [messages, setMessages]   = useState([]);
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [error, setError]         = useState(null);
+
+  const abortRef         = useRef(null);
+  const chunkBufRef      = useRef({});
+  const flushIntervalRef = useRef(null);
+
+  // Flush accumulated chunk buffers to stage preview state at ~12fps
+  useEffect(() => {
+    if (!isStreaming) return;
+    const id = setInterval(() => {
+      const buf = chunkBufRef.current;
+      if (Object.keys(buf).length === 0) return;
+      setStages((prev) =>
+        prev.map((s, i) =>
+          buf[i] !== undefined ? { ...s, preview: buf[i].slice(0, 120) } : s
+        )
+      );
+    }, 80);
+    flushIntervalRef.current = id;
+    return () => clearInterval(id);
+  }, [isStreaming]);
+
+  const startStream = useCallback(async (body, { initialStages } = {}) => {
+    const controller = new AbortController();
+    abortRef.current = controller;
+    chunkBufRef.current = {};
+    setError(null);
+    setIsStreaming(true);
+
+    if (initialStages) {
+      setStages(initialStages.map((label) => ({ label, status: "pending", preview: undefined })));
+    }
+
+    // Add a streaming placeholder message in REPL history (for smart_update)
+    if (body.action === "smart_update") {
+      setMessages((prev) => [
+        ...prev,
+        { id: crypto.randomUUID(), role: "ai", text: "Analysing PRD…", status: "streaming" },
+      ]);
+    }
+
+    try {
+      for await (const { event, data } of streamPrdAi(body, controller.signal)) {
+        if (event === "stage_start") {
+          const i = data.stage_index ?? 0;
+          setStages((prev) =>
+            prev.map((s, idx) =>
+              idx < i    ? { ...s, status: "done", preview: undefined } :
+              idx === i  ? { ...s, status: "streaming" } : s
+            )
+          );
+        } else if (event === "stage_chunk") {
+          const i = data.stage_index ?? 0;
+          chunkBufRef.current[i] = (chunkBufRef.current[i] ?? "") + (data.chunk ?? "");
+        } else if (event === "stage_done") {
+          const i = data.stage_index ?? 0;
+          delete chunkBufRef.current[i];
+          setStages((prev) =>
+            prev.map((s, idx) =>
+              idx === i ? { ...s, status: "done", preview: undefined } : s
+            )
+          );
+        } else if (event === "update_progress") {
+          const msg = data.message ?? "Updating…";
+          setMessages((prev) => {
+            const idx = prev.findLastIndex((m) => m.status === "streaming");
+            if (idx === -1) return prev;
+            return prev.map((m, i) => i === idx ? { ...m, text: msg } : m);
+          });
+        } else if (event === "done") {
+          const summary = data.summary ? ` — ${data.summary}` : "";
+          setStages((prev) =>
+            prev.map((s) =>
+              s.status === "streaming" || s.status === "pending"
+                ? { ...s, status: "done", preview: undefined }
+                : s
+            )
+          );
+          if (body.action === "smart_update") {
+            setMessages((prev) =>
+              prev.map((m) =>
+                m.status === "streaming"
+                  ? { ...m, role: "status", text: `✓ Done${summary}`, status: "done" }
+                  : m
+              )
+            );
+          }
+          break;
+        } else if (event === "error") {
+          const msg = data.message ?? "Generation failed";
+          setError(msg);
+          setMessages((prev) =>
+            prev.map((m) =>
+              m.status === "streaming"
+                ? { ...m, text: msg, status: "error" }
+                : m
+            )
+          );
+          break;
+        }
+      }
+    } catch (e) {
+      if (e.name !== "AbortError") {
+        const msg = e.message ?? "Unexpected error";
+        setError(msg);
+        setMessages((prev) =>
+          prev.map((m) =>
+            m.status === "streaming" ? { ...m, text: msg, status: "error" } : m
+          )
+        );
+      }
+    } finally {
+      clearInterval(flushIntervalRef.current);
+      setIsStreaming(false);
+      abortRef.current = null;
+    }
+  }, []);
+
+  const abort = useCallback(() => {
+    abortRef.current?.abort();
+  }, []);
+
+  return { stages, setStages, messages, setMessages, isStreaming, error, startStream, abort };
+}

package/src/hooks/useTerminalSize.js

@@ -0,0 +1,24 @@
+import { useState, useEffect } from "react";
+import { useStdout } from "ink";
+
+/**
+ * Returns live terminal dimensions, updating on window resize.
+ * @returns {{ columns: number, rows: number }}
+ */
+export function useTerminalSize() {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState({
+    columns: stdout?.columns ?? 80,
+    rows:    stdout?.rows    ?? 24,
+  });
+
+  useEffect(() => {
+    if (!stdout) return;
+    const handler = () =>
+      setSize({ columns: stdout.columns ?? 80, rows: stdout.rows ?? 24 });
+    stdout.on("resize", handler);
+    return () => stdout.off("resize", handler);
+  }, [stdout]);
+
+  return size;
+}

package/src/index.js

@@ -13,7 +13,7 @@ import { creditsCommand } from "./commands/credits.js";
 import { dashboardCommand } from "./commands/dashboard.js";
 
 const LOGO = `
-\x1b[1m\x1b[36m  PRDForge CLI\x1b[0m  \x1b[2mv0.1.0\x1b[0m
+\x1b[1m\x1b[36m  PRDForge CLI\x1b[0m  \x1b[2mv0.2.0\x1b[0m
   \x1b[90mThe planning layer for AI-first development\x1b[0m
 `;
 
@@ -22,14 +22,17 @@ const program = new Command();
 program
   .name("prdforge")
   .description("PRDForge CLI — generate, manage, and export PRDs from your terminal or AI agents")
-  .version("0.1.0", "-v, --version")
+  .version("0.2.0", "-v, --version")
   .addHelpText("beforeAll", LOGO)
-  .hook("preAction", async () => {
+  .option("--debug", "Enable verbose debug logging")
+  .hook("preAction", async (thisCommand) => {
     // Load .env from cwd if present
     try {
       const { config: dotenv } = await import("dotenv");
       dotenv();
     } catch {}
+    // Activate debug mode
+    if (thisCommand.opts().debug) global.__prdforgeDebug = true;
   });
 
 program.addCommand(authCommand());
@@ -51,14 +54,16 @@ program.on("command:*", (cmds) => {
   process.exit(1);
 });
 
-// When run with no arguments: open dashboard if authenticated, else show help
+// When run with no arguments: open dashboard if authenticated, else show welcome screen
 if (process.argv.length === 2) {
   const { getApiKey } = await import("./utils/config.js");
   if (getApiKey()) {
     const { dashboardCommand } = await import("./commands/dashboard.js");
     await dashboardCommand().parseAsync([], { from: "user" });
   } else {
-    program.help();
+    const { printWelcome } = await import("./utils/logo.js");
+    printWelcome();
+    process.exit(0);
   }
 }