prdforge-cli 0.1.0

package/src/commands/config.js

@@ -0,0 +1,58 @@
+import { Command } from "commander";
+import { config } from "../utils/config.js";
+import { success, error, info, header, table } from "../utils/output.js";
+
+const CONFIGURABLE_KEYS = ["apiUrl", "defaultFormat", "defaultProject", "outputDir"];
+
+export function configCommand() {
+  const cmd = new Command("config").description("Manage CLI configuration");
+
+  cmd
+    .command("list")
+    .description("Show all current configuration values")
+    .action(() => {
+      header("Configuration");
+      table(
+        ["Key", "Value"],
+        CONFIGURABLE_KEYS.map((k) => [k, String(config.get(k) || "")])
+      );
+      info(`Config file: ${config.path}`);
+    });
+
+  cmd
+    .command("set <key> <value>")
+    .description("Set a configuration value")
+    .action((key, value) => {
+      if (!CONFIGURABLE_KEYS.includes(key)) {
+        error(`Unknown key: ${key}`);
+        info(`Valid keys: ${CONFIGURABLE_KEYS.join(", ")}`);
+        process.exit(1);
+      }
+      config.set(key, value);
+      success(`${key} = ${value}`);
+    });
+
+  cmd
+    .command("get <key>")
+    .description("Get a configuration value")
+    .action((key) => {
+      console.log(config.get(key) ?? "");
+    });
+
+  cmd
+    .command("reset")
+    .description("Reset all configuration to defaults")
+    .action(async () => {
+      const { default: inquirer } = await import("inquirer");
+      const { confirm } = await inquirer.prompt([
+        { type: "confirm", name: "confirm", message: "Reset all config? (API key will be kept)", default: false },
+      ]);
+      if (!confirm) return;
+      const key = config.get("apiKey");
+      config.clear();
+      if (key) config.set("apiKey", key);
+      success("Configuration reset to defaults.");
+    });
+
+  return cmd;
+}

package/src/commands/credits.js

@@ -0,0 +1,21 @@
+import { Command } from "commander";
+import { user, isAuthError } from "../api/client.js";
+import { requireApiKey } from "../utils/config.js";
+import { header, dim, error } from "../utils/output.js";
+
+export function creditsCommand() {
+  return new Command("credits")
+    .description("Show monthly credit usage and subscription tier")
+    .action(async () => {
+      requireApiKey();
+      try {
+        const data = await user.validate();
+        header("Credits");
+        dim(`  Credits used this month:  ${data.credits_used_this_month}`);
+        dim(`  Subscription tier:        ${data.subscription}`);
+      } catch (err) {
+        error(err.message);
+        process.exit(isAuthError(err) ? 2 : 1);
+      }
+    });
+}

package/src/commands/dashboard.js

@@ -0,0 +1,88 @@
+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() {
+  return new Command("dashboard")
+    .alias("dash")
+    .description("Open interactive project overview (keyboard navigable)")
+    .action(async () => {
+      requireApiKey();
+
+      let createArgs = null;
+
+      const { waitUntilExit } = render(
+        React.createElement(Dashboard, {
+          onCreateNew: (args) => { createArgs = args; },
+        })
+      );
+
+      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/commands/export.js

@@ -0,0 +1,67 @@
+import { Command } from "commander";
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { exports_, isAuthError } from "../api/client.js";
+import { config } from "../utils/config.js";
+import { success, error, info, dim } from "../utils/output.js";
+
+/** API supports markdown and json only. See SYNC.md for adding new formats. */
+const FORMATS = ["markdown", "json"];
+
+export function exportCommand() {
+  const cmd = new Command("export").description("Export a PRD in various formats");
+
+  cmd
+    .argument("<projectId>", "Project ID to export")
+    .option("-f, --format <format>", `Export format: ${FORMATS.join(", ")}`, "markdown")
+    .option("-o, --output <path>", "Output file path (default: ./prd-exports/<id>.<ext>)")
+    .option("--stdout", "Print to stdout instead of saving to file")
+    .action(async (projectId, opts) => {
+      const { default: ora } = await import("ora");
+
+      if (!FORMATS.includes(opts.format)) {
+        error(`Unknown format: ${opts.format}. Valid options: ${FORMATS.join(", ")}`);
+        process.exit(1);
+      }
+
+      const spinner = ora(`Exporting as ${opts.format}…`).start();
+      try {
+        const result = await exports_.export(projectId, opts.format);
+        spinner.stop();
+
+        const content =
+          opts.format === "json"
+            ? JSON.stringify(result.data ?? result, null, 2)
+            : result.content ?? result.data ?? String(result);
+
+        if (opts.stdout) {
+          console.log(content);
+          return;
+        }
+
+        const ext = opts.format === "markdown" ? "md" : opts.format;
+        const outDir = config.get("outputDir");
+        mkdirSync(outDir, { recursive: true });
+        const filePath = opts.output || join(outDir, `${projectId.slice(0, 8)}.${ext}`);
+        writeFileSync(filePath, content, "utf8");
+
+        success(`Exported to: ${filePath}`);
+        dim(`  Format: ${opts.format}`);
+        info("Feed this file directly to Claude Code, Cursor, or any AI coding tool.");
+      } catch (err) {
+        spinner.fail("Export failed");
+        error(err.message);
+        process.exit(isAuthError(err) ? 2 : 1);
+      }
+    });
+
+  cmd.addHelpText(
+    "after",
+    `
+Examples:
+  prdforge export <projectId> -f markdown -o PRD.md
+  prdforge export <projectId> --format json --stdout
+`
+  );
+  return cmd;
+}

package/src/commands/generate.js

@@ -0,0 +1,117 @@
+import { Command } from "commander";
+import { writeFileSync, mkdirSync, existsSync, renameSync } from "fs";
+import { join } from "path";
+import { projects, prd, exports_, isAuthError } from "../api/client.js";
+import { success, error, info, dim } from "../utils/output.js";
+
+function timestamp() {
+  const d = new Date();
+  return [
+    d.getFullYear(),
+    String(d.getMonth() + 1).padStart(2, "0"),
+    String(d.getDate()).padStart(2, "0"),
+    String(d.getHours()).padStart(2, "0"),
+    String(d.getMinutes()).padStart(2, "0"),
+    String(d.getSeconds()).padStart(2, "0"),
+  ].join("-");
+}
+
+export function generateCommand() {
+  const cmd = new Command("generate")
+    .description("Generate a PRD and save it to your app folder (with optional backup of existing PRD.md)")
+    .option("-n, --name <name>", "Project name (for new PRD)")
+    .option("-p, --prompt <prompt>", "Product idea or update prompt (or set PRDFORGE_PROMPT)")
+    .option("--project <id>", "Existing project ID (for update or refresh)")
+    .option("--refresh", "Regenerate all stale stages, then save")
+    .option("-d, --dir <path>", "App folder to write PRD.md (default: current directory)", process.cwd())
+    .option("-o, --output <path>", "Output filename (default: PRD.md)", "PRD.md")
+    .option("--no-backup", "Do not backup existing PRD.md before overwriting")
+    .option("-m, --model <modelId>", "AI model ID to use")
+    .option("--json", "Output raw JSON instead of writing file")
+    .addHelpText(
+      "after",
+      `
+Examples:
+  prdforge generate -n "My App" -p "A todo app with due dates and tags"
+  prdforge generate --project <id> -p "Add OAuth section"
+  prdforge generate --project <id> --refresh
+  prdforge generate -n "API" -p "REST API for payments" -d ./my-app -o PRD.md
+`
+    );
+
+  cmd.action(async (opts) => {
+    const { default: ora } = await import("ora");
+    const prompt = opts.prompt ?? process.env.PRDFORGE_PROMPT ?? "";
+
+    const isRefresh = !!opts.project && !!opts.refresh;
+    const isUpdate = !!opts.project && !opts.refresh && prompt !== "";
+    const isNew = !!opts.name && prompt !== "";
+
+    if (!isNew && !isUpdate && !isRefresh) {
+      if (opts.name) {
+        error("Provide -p/--prompt or set PRDFORGE_PROMPT to generate a new PRD.");
+      } else {
+        error("Use -n/--name with -p/--prompt for a new PRD, or --project <id> with -p/--prompt or --refresh.");
+      }
+      process.exit(1);
+    }
+
+    let projectId;
+    let content;
+
+    try {
+      if (isNew) {
+        const spinner = ora("Creating project…").start();
+        const project = await projects.create(opts.name, prompt);
+        projectId = project.id;
+        spinner.text = "Generating PRD (this may take ~30–60s)…";
+        await prd.generate(projectId, prompt, opts.model);
+        spinner.succeed("PRD generated!");
+      } else if (isUpdate) {
+        projectId = opts.project;
+        const spinner = ora("Analysing and merging update…").start();
+        await prd.update(projectId, prompt, opts.model);
+        spinner.succeed("PRD updated!");
+      } else {
+        projectId = opts.project;
+        const spinner = ora("Regenerating stale stages…").start();
+        await prd.regenerateStale(projectId, opts.model);
+        spinner.succeed("Stale stages refreshed!");
+      }
+
+      const spinner = ora("Exporting markdown…").start();
+      const result = await exports_.export(projectId, "markdown");
+      spinner.stop();
+      content =
+        result.content ?? result.data ?? (typeof result === "string" ? result : JSON.stringify(result, null, 2));
+    } catch (err) {
+      if (opts.json && err.message) {
+        console.error(JSON.stringify({ error: err.message, httpStatus: err.httpStatus }));
+      } else {
+        error(err.message);
+      }
+      process.exit(isAuthError(err) ? 2 : 1);
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify({ project_id: projectId, content }, null, 2));
+      return;
+    }
+
+    const dir = opts.dir || process.cwd();
+    const outputPath = join(dir, opts.output || "PRD.md");
+    mkdirSync(dir, { recursive: true });
+
+    if (existsSync(outputPath) && opts.backup !== false) {
+      const backupPath = `${outputPath}.backup.${timestamp()}`;
+      renameSync(outputPath, backupPath);
+      info(`Backed up existing file to ${backupPath}`);
+    }
+
+    writeFileSync(outputPath, content, "utf8");
+    success(`PRD saved to ${outputPath}`);
+    dim("  Use this file with Cursor, Claude Code, or any AI coding tool.");
+  });
+
+  return cmd;
+}

package/src/commands/mcp.js

@@ -0,0 +1,100 @@
+import { Command } from "commander";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { projects, prd, exports_ } from "../api/client.js";
+import { requireApiKey } from "../utils/config.js";
+
+export function mcpCommand() {
+  const cmd = new Command("mcp").description("MCP (Model Context Protocol) server for PRDForge");
+
+  cmd
+    .command("serve")
+    .description("Run the MCP server (stdio). Use with Cursor or other MCP clients.")
+    .action(async () => {
+      // Ensure API key is available before starting (fail fast)
+      requireApiKey();
+
+      const mcpServer = new McpServer({
+        name: "prdforge",
+        version: "0.1.0",
+      });
+
+      mcpServer.registerTool(
+        "prdforge_list_projects",
+        {
+          description: "List all PRDForge projects for the authenticated user",
+          inputSchema: {},
+        },
+        async () => {
+          try {
+            const data = await projects.list();
+            const text =
+              Array.isArray(data) && data.length > 0
+                ? JSON.stringify(data.map((p) => ({ id: p.id, name: p.name, updated_at: p.updated_at })), null, 2)
+                : "No projects yet.";
+            return { content: [{ type: "text", text }] };
+          } catch (err) {
+            return { content: [{ type: "text", text: err.message }], isError: true };
+          }
+        }
+      );
+
+      mcpServer.registerTool(
+        "prdforge_get_prd",
+        {
+          description: "Export a PRD project as markdown by project ID",
+          inputSchema: {
+            type: "object",
+            properties: {
+              project_id: { type: "string", description: "PRDForge project ID (UUID)" },
+            },
+            required: ["project_id"],
+          },
+        },
+        async ({ project_id }) => {
+          try {
+            const result = await exports_.export(project_id, "markdown");
+            const content =
+              result.content ?? result.data ?? (typeof result === "string" ? result : JSON.stringify(result, null, 2));
+            return { content: [{ type: "text", text: content }] };
+          } catch (err) {
+            return { content: [{ type: "text", text: err.message }], isError: true };
+          }
+        }
+      );
+
+      mcpServer.registerTool(
+        "prdforge_get_sections",
+        {
+          description: "Get PRD sections for a project (optionally filter by section_type)",
+          inputSchema: {
+            type: "object",
+            properties: {
+              project_id: { type: "string", description: "PRDForge project ID (UUID)" },
+              section_type: { type: "string", description: "Optional section type filter (e.g. feature_list)" },
+            },
+            required: ["project_id"],
+          },
+        },
+        async ({ project_id, section_type }) => {
+          try {
+            const sections = await prd.getSections(project_id);
+            const filtered = section_type
+              ? sections.filter((s) => s.section_type === section_type)
+              : sections;
+            const text = JSON.stringify(filtered, null, 2);
+            return { content: [{ type: "text", text }] };
+          } catch (err) {
+            return { content: [{ type: "text", text: err.message }], isError: true };
+          }
+        }
+      );
+
+      const transport = new StdioServerTransport();
+      await mcpServer.connect(transport);
+      // Log to stderr so stdout stays clean for JSON-RPC
+      console.error("PRDForge MCP server running on stdio. Press Ctrl+C to stop.");
+    });
+
+  return cmd;
+}

package/src/commands/prd.js

@@ -0,0 +1,221 @@
+import { Command } from "commander";
+import React from "react";
+import { render } from "ink";
+import { prd, projects, isAuthError } from "../api/client.js";
+import { success, error, info, dim, header, table, printPRDSection } from "../utils/output.js";
+import { PrdCreation, buildStages, setStageStatus, markAllDone } from "../ui/PrdCreation.js";
+import { theme } from "../ui/theme.js";
+
+export function prdCommand() {
+  const cmd = new Command("prd").description("Generate, view, and update PRDs");
+
+  // prdforge prd list
+  cmd
+    .command("list")
+    .description("List all your PRD projects")
+    .option("--json", "Output raw JSON")
+    .action(async (opts) => {
+      const { default: ora } = await import("ora");
+      const spinner = ora("Fetching projects…").start();
+      try {
+        const data = await projects.list();
+        spinner.stop();
+        if (opts.json) {
+          console.log(JSON.stringify(data, null, 2));
+          return;
+        }
+        header("Your PRD Projects");
+        if (!data?.length) {
+          info("No projects yet. Run 'prdforge prd create' to start.");
+          return;
+        }
+        table(
+          ["ID", "Name", "Stages", "Updated"],
+          data.map((p) => [
+            p.id.slice(0, 8) + "…",
+            p.name,
+            `${p.completed_stages || 0}/8`,
+            new Date(p.updated_at).toLocaleDateString(),
+          ])
+        );
+      } catch (err) {
+        spinner.fail("Failed");
+        error(err.message);
+        process.exit(isAuthError(err) ? 2 : 1);
+      }
+    });
+
+  // prdforge prd get <id>
+  cmd
+    .command("get <projectId>")
+    .description("Show all PRD sections for a project")
+    .option("--section <type>", "Show a specific section type")
+    .option("--json", "Output raw JSON")
+    .action(async (projectId, opts) => {
+      const { default: ora } = await import("ora");
+      const spinner = ora("Loading PRD…").start();
+      try {
+        const sections = await prd.getSections(projectId);
+        spinner.stop();
+        if (opts.json) {
+          console.log(JSON.stringify(sections, null, 2));
+          return;
+        }
+        const filtered = opts.section
+          ? sections.filter((s) => s.section_type === opts.section)
+          : sections;
+        header(`PRD Sections (${filtered.length})`);
+        filtered.forEach(printPRDSection);
+      } catch (err) {
+        spinner.fail("Failed");
+        error(err.message);
+        process.exit(isAuthError(err) ? 2 : 1);
+      }
+    });
+
+  // prdforge prd create
+  cmd
+    .command("create")
+    .description("Create a new PRD project from a prompt")
+    .requiredOption("-n, --name <name>", "Project name")
+    .option("-p, --prompt <prompt>", "Product idea or description")
+    .option("-m, --model <modelId>", "AI model ID to use")
+    .option("--json", "Output raw JSON")
+    .action(async (opts) => {
+      let prompt = opts.prompt;
+
+      if (!prompt) {
+        const { default: inquirer } = await import("inquirer");
+        const ans = await inquirer.prompt([
+          {
+            type: "editor",
+            name: "prompt",
+            message: "Describe your product idea (opens your $EDITOR):",
+          },
+        ]);
+        prompt = ans.prompt;
+      }
+
+      // If JSON output requested, use plain spinner (no TUI)
+      if (opts.json) {
+        const { default: ora } = await import("ora");
+        const spinner = ora("Creating project…").start();
+        try {
+          const project = await projects.create(opts.name, prompt);
+          spinner.text = "Generating PRD…";
+          const result = await prd.generate(project.id, prompt, opts.model);
+          spinner.stop();
+          console.log(JSON.stringify({ project, result }, null, 2));
+        } catch (err) {
+          spinner.fail("Failed");
+          error(err.message);
+          process.exit(isAuthError(err) ? 2 : 1);
+        }
+        return;
+      }
+
+      // Animated Ink stage progress
+      let stages = buildStages(theme.stages);
+      stages = setStageStatus(stages, 0, "active");
+
+      const inkInstance = render(
+        React.createElement(PrdCreation, { projectName: opts.name, stages })
+      );
+
+      // Advance stage indicators on a timer while the API call runs (~8s per stage)
+      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: opts.name, stages })
+          );
+        }
+      }, STAGE_INTERVAL_MS);
+
+      try {
+        const project = await projects.create(opts.name, prompt);
+        const result = await prd.generate(project.id, prompt, opts.model);
+        clearInterval(timer);
+        stages = markAllDone(stages);
+        inkInstance.rerender(
+          React.createElement(PrdCreation, { projectName: opts.name, stages })
+        );
+        inkInstance.unmount();
+        success(`Project "${opts.name}" 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);
+      }
+    });
+
+  // prdforge prd update <id>
+  cmd
+    .command("update <projectId>")
+    .description("Intelligently merge an update into an existing PRD")
+    .option("-p, --prompt <prompt>", "What to update or add")
+    .option("-m, --model <modelId>", "AI model ID to use")
+    .option("--json", "Output raw JSON")
+    .action(async (projectId, opts) => {
+      const { default: ora } = await import("ora");
+      let prompt = opts.prompt;
+
+      if (!prompt) {
+        const { default: inquirer } = await import("inquirer");
+        const ans = await inquirer.prompt([
+          {
+            type: "editor",
+            name: "prompt",
+            message: "Describe the update (opens your $EDITOR):",
+          },
+        ]);
+        prompt = ans.prompt;
+      }
+
+      const spinner = ora("Analysing and merging update…").start();
+      try {
+        const result = await prd.update(projectId, prompt, opts.model);
+        spinner.succeed("PRD updated!");
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          success(`Smart merge complete`);
+          if (result.summary) dim(`  Summary: ${result.summary}`);
+          if (result.sectionsUpdated != null) dim(`  Sections updated: ${result.sectionsUpdated}`);
+          if (result.cascadeTriggered) info("  Downstream stages (modules, tasks, etc.) were regenerated.");
+        }
+      } catch (err) {
+        spinner.fail("Failed");
+        error(err.message);
+        process.exit(isAuthError(err) ? 2 : 1);
+      }
+    });
+
+  // prdforge prd refresh <id>
+  cmd
+    .command("refresh <projectId>")
+    .description("Regenerate all stale stages for a project")
+    .option("-m, --model <modelId>", "AI model ID to use")
+    .action(async (projectId, opts) => {
+      const { default: ora } = await import("ora");
+      const spinner = ora("Regenerating stale stages…").start();
+      try {
+        const result = await prd.regenerateStale(projectId, opts.model);
+        spinner.succeed("All stale stages refreshed!");
+        if (result?.summary) dim(`  ${result.summary}`);
+      } catch (err) {
+        spinner.fail("Failed");
+        error(err.message);
+        process.exit(isAuthError(err) ? 2 : 1);
+      }
+    });
+
+  return cmd;
+}