pm-workflow-studio 0.1.0

package/bin/pmflow.js

@@ -0,0 +1,463 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+const CODEX_MIRROR = path.join(PACKAGE_ROOT, ".codex");
+const CLAUDE_MIRROR = path.join(PACKAGE_ROOT, ".claude");
+const CODEX_TEMPLATES = path.join(CODEX_MIRROR, "templates");
+const CODEX_ROLE_SKILLS = path.join(CODEX_MIRROR, "role-skills");
+const CODEX_BUNDLED_SKILLS = path.join(CODEX_MIRROR, "bundled-skills");
+
+const DOC_TEMPLATES = [
+  ["project-config.md", "project-config.md"],
+  ["demand-analysis/templates/prd.md", "prd.md"],
+  ["demand-analysis/templates/handoff-prd.md", "handoff-prd.md"],
+  ["tech-architecture/templates/tech-architecture.md", "tech-architecture.md"],
+  ["tech-architecture/templates/handoff-architecture.md", "handoff-architecture.md"],
+  ["ui-prototype-design/templates/ui-design.md", "ui-design.md"],
+  ["ui-prototype-design/templates/handoff-ui.md", "handoff-ui.md"],
+  ["ui-prototype-design/templates/prototype-review.md", "prototype-review.md"],
+  ["dev-task-planning/templates/dev-tasks.md", "dev-tasks.md"],
+];
+
+function printHelp() {
+  console.log(`PM Workflow Studio
+
+Usage:
+  pmflow init [--ai auto|codex|claude] [--root <dir>] [--name <product name>]
+  pm-workflow init [--ai auto|codex|claude] [--root <dir>] [--name <product name>]
+
+Options:
+  --ai, --cli   AI CLI layout to generate. Defaults to auto.
+              auto: choose by target directory, empty dirs default to Codex.
+              codex: generate .codex + .agents structure.
+              claude: generate .claude structure for Claude Code.
+  --root        Target workspace directory. Defaults to current directory.
+  --name        Product name for generated templates. Defaults to "My Product".
+  -h, --help    Show help.
+
+Examples:
+  pmflow init --ai codex --root ./pm-workflow-demo --name "习惯打卡"
+  pmflow init --ai claude --root ./pm-workflow-claude-demo --name "习惯打卡"
+  pmflow init --ai auto --name "习惯打卡"
+
+Runtime:
+  Requires Node.js only. Python is not required for pmflow init.
+`);
+}
+
+function fail(message) {
+  console.error(`pmflow: ${message}`);
+  console.error("Run `pmflow --help` for usage.");
+  process.exit(1);
+}
+
+function exists(target) {
+  return fs.existsSync(target);
+}
+
+function isDirectory(target) {
+  try {
+    return fs.statSync(target).isDirectory();
+  } catch (_error) {
+    return false;
+  }
+}
+
+function ensureDir(target) {
+  fs.mkdirSync(target, { recursive: true });
+}
+
+function relativeTo(root, target) {
+  return path.relative(root, target).split(path.sep).join("/");
+}
+
+function normalizeAi(value) {
+  const normalized = String(value || "auto").toLowerCase();
+  if (normalized === "claude-code") return "claude";
+  if (["auto", "codex", "claude"].includes(normalized)) return normalized;
+  if (normalized === "kiro") {
+    fail("--ai kiro is not supported yet. Use --ai auto, --ai codex, or --ai claude.");
+  }
+  fail(`unsupported --ai value "${value}". Expected auto, codex, or claude.`);
+}
+
+function parseInitArgs(argv) {
+  const options = {
+    ai: "auto",
+    root: ".",
+    name: "My Product",
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "-h" || arg === "--help") {
+      printHelp();
+      process.exit(0);
+    }
+    if (arg === "--ai" || arg === "--cli") {
+      const value = argv[index + 1];
+      if (!value) fail(`${arg} requires a value.`);
+      options.ai = normalizeAi(value);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--ai=")) {
+      options.ai = normalizeAi(arg.slice("--ai=".length));
+      continue;
+    }
+    if (arg.startsWith("--cli=")) {
+      options.ai = normalizeAi(arg.slice("--cli=".length));
+      continue;
+    }
+    if (arg === "--root") {
+      const value = argv[index + 1];
+      if (!value) fail("--root requires a value.");
+      options.root = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--root=")) {
+      options.root = arg.slice("--root=".length);
+      continue;
+    }
+    if (arg === "--name") {
+      const value = argv[index + 1];
+      if (!value) fail("--name requires a value.");
+      options.name = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--name=")) {
+      options.name = arg.slice("--name=".length);
+      continue;
+    }
+    fail(`unknown argument "${arg}".`);
+  }
+
+  return options;
+}
+
+function templatePath(name) {
+  const centralPath = path.join(CODEX_TEMPLATES, name);
+  if (exists(centralPath)) return centralPath;
+  const rolePath = path.join(CODEX_ROLE_SKILLS, name);
+  if (exists(rolePath)) return rolePath;
+  fail(`template not found in .codex mirror: ${name}`);
+}
+
+function renderTemplate(name, productName) {
+  return fs.readFileSync(templatePath(name), "utf8").replaceAll("{{PRODUCT_NAME}}", productName);
+}
+
+function writeIfMissing(target, content) {
+  if (exists(target)) return false;
+  ensureDir(path.dirname(target));
+  fs.writeFileSync(target, content, "utf8");
+  return true;
+}
+
+function detectCli(root, requested) {
+  if (requested !== "auto") return requested;
+  if (exists(path.join(root, ".claude"))) return "claude";
+  if (exists(path.join(root, ".codex")) || exists(path.join(root, ".agents"))) return "codex";
+  return "codex";
+}
+
+function ignoredByDefault(itemPath) {
+  const name = path.basename(itemPath);
+  return name === "__pycache__" || name === ".DS_Store" || name.endsWith(".pyc");
+}
+
+function copyTreeIfMissing(src, dest, ignoreFn = ignoredByDefault) {
+  if (exists(dest) || !exists(src) || ignoreFn(src)) return false;
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    ensureDir(dest);
+    for (const name of fs.readdirSync(src).sort()) {
+      copyTreeIfMissing(path.join(src, name), path.join(dest, name), ignoreFn);
+    }
+  } else {
+    ensureDir(path.dirname(dest));
+    fs.copyFileSync(src, dest);
+  }
+  return true;
+}
+
+function copyMirrorChildren(srcRoot, destRoot, options = {}) {
+  const copied = [];
+  if (!isDirectory(srcRoot)) return copied;
+  ensureDir(destRoot);
+  for (const name of fs.readdirSync(srcRoot).sort()) {
+    if (options.skipNames && options.skipNames.has(name)) continue;
+    const src = path.join(srcRoot, name);
+    const dest = path.join(destRoot, name);
+    if (copyTreeIfMissing(src, dest, options.ignoreFn || ignoredByDefault)) {
+      copied.push(relativeTo(options.reportRoot || destRoot, dest));
+    }
+  }
+  return copied;
+}
+
+function copyCodexAgents(root) {
+  const target = path.join(root, ".codex", "agents");
+  const copied = [];
+  ensureDir(target);
+  const source = path.join(CODEX_MIRROR, "agents");
+  if (!isDirectory(source)) return copied;
+  for (const name of fs.readdirSync(source).sort()) {
+    if (!name.endsWith(".toml")) continue;
+    const src = path.join(source, name);
+    const dest = path.join(target, name);
+    if (!exists(dest)) {
+      fs.copyFileSync(src, dest);
+      copied.push(relativeTo(root, dest));
+    }
+  }
+  return copied;
+}
+
+function copyCodexSkill(root) {
+  const target = path.join(root, ".agents", "skills", "pm-workflow");
+  const ignore = (itemPath) => {
+    if (ignoredByDefault(itemPath)) return true;
+    const parent = path.basename(path.dirname(itemPath));
+    return parent === "agents" && path.basename(itemPath).endsWith(".toml");
+  };
+  if (copyTreeIfMissing(CODEX_MIRROR, target, ignore)) {
+    return [relativeTo(root, target)];
+  }
+  return [];
+}
+
+function copyRoleSkills(root) {
+  const copied = [];
+  const targetRoot = path.join(root, ".agents", "skills");
+  ensureDir(targetRoot);
+  if (!isDirectory(CODEX_ROLE_SKILLS)) return copied;
+  for (const name of fs.readdirSync(CODEX_ROLE_SKILLS).sort()) {
+    const src = path.join(CODEX_ROLE_SKILLS, name);
+    if (!isDirectory(src)) continue;
+    const dest = path.join(targetRoot, name);
+    if (copyTreeIfMissing(src, dest)) {
+      copied.push(relativeTo(root, dest));
+    }
+  }
+  return copied;
+}
+
+function copyImpeccableSkill(root) {
+  const src = path.join(CODEX_BUNDLED_SKILLS, "impeccable");
+  const dest = path.join(root, ".agents", "skills", "impeccable");
+  if (exists(dest)) return [];
+  if (!exists(path.join(src, "SKILL.md"))) return [];
+  copyTreeIfMissing(src, dest);
+  return [relativeTo(root, dest)];
+}
+
+function removeCodexAgentManifest(skillDir) {
+  const openaiManifest = path.join(skillDir, "agents", "openai.yaml");
+  if (exists(openaiManifest)) fs.unlinkSync(openaiManifest);
+  const agentsDir = path.join(skillDir, "agents");
+  if (isDirectory(agentsDir) && fs.readdirSync(agentsDir).length === 0) {
+    fs.rmdirSync(agentsDir);
+  }
+}
+
+function writePluginManifest(root) {
+  const manifest = `{
+  "name": "pm-workflow",
+  "version": "0.1.0",
+  "description": "Codex-native AI product development studio framework.",
+  "author": {
+    "name": "[TODO: author name]",
+    "email": "[TODO: author email]",
+    "url": "[TODO: author url]"
+  },
+  "homepage": "[TODO: homepage]",
+  "repository": "[TODO: repository]",
+  "license": "[TODO: license]",
+  "keywords": ["codex", "product-management", "workflow", "prototype", "planning"],
+  "skills": "./.agents/skills/",
+  "interface": {
+    "displayName": "PM Workflow",
+    "shortDescription": "AI 产品开发工作室：从模糊想法到可执行开发蓝图。",
+    "longDescription": "A Codex-native product development studio with role agents, repo-scoped skills, staged documents, quality reviews, HTML prototypes, and delivery packaging.",
+    "developerName": "[TODO: developer name]",
+    "category": "Productivity",
+    "capabilities": ["Interactive", "Write"],
+    "defaultPrompt": [
+      "我想做一个产品，帮我从需求开始梳理",
+      "澄清需求",
+      "开始分析需求",
+      "审核一下当前阶段"
+    ],
+    "brandColor": "#2563EB"
+  }
+}
+`;
+  return writeIfMissing(path.join(root, ".codex-plugin", "plugin.json"), manifest);
+}
+
+function createCommonStructure(root, productName, includeAgentsMd) {
+  const dirs = [
+    path.join(root, "docs"),
+    path.join(root, "prototype"),
+    path.join(root, "prototype", "directions"),
+    path.join(root, "prototype", "pages"),
+    path.join(root, "prototype", "layout"),
+    path.join(root, "prototype", "components"),
+    path.join(root, "prototype", "assets"),
+    path.join(root, "prototype", "review"),
+    path.join(root, "prototype", "review", "screenshots"),
+    path.join(root, "prototype", "review", "screenshots", "desktop"),
+    path.join(root, "prototype", "review", "screenshots", "tablet"),
+    path.join(root, "prototype", "review", "screenshots", "mobile"),
+    path.join(root, "outputs", "dev-package"),
+  ];
+  dirs.forEach(ensureDir);
+
+  const created = [];
+  for (const [templateName, filename] of DOC_TEMPLATES) {
+    const target = path.join(root, "docs", filename);
+    if (writeIfMissing(target, renderTemplate(templateName, productName))) {
+      created.push(relativeTo(root, target));
+    }
+  }
+
+  const statePath = path.join(root, "docs", "workflow-state.json");
+  if (writeIfMissing(statePath, renderTemplate("workflow-state.json", productName))) {
+    created.push("docs/workflow-state.json");
+  }
+
+  if (includeAgentsMd) {
+    const agentsPath = path.join(root, "AGENTS.md");
+    if (writeIfMissing(agentsPath, renderTemplate("framework-AGENTS.md", productName))) {
+      created.push("AGENTS.md");
+    }
+  }
+
+  const readmePath = path.join(root, "README.md");
+  if (writeIfMissing(readmePath, renderTemplate("framework-README.md", productName))) {
+    created.push("README.md");
+  }
+
+  const prototypeReadmePath = path.join(root, "prototype", "README.md");
+  if (writeIfMissing(prototypeReadmePath, renderTemplate("prototype-README.md", productName))) {
+    created.push("prototype/README.md");
+  }
+  return created;
+}
+
+function createCodexStructure(root, productName) {
+  [
+    path.join(root, ".codex", "agents"),
+    path.join(root, ".agents", "context"),
+    path.join(root, ".agents", "skills"),
+  ].forEach(ensureDir);
+
+  const created = createCommonStructure(root, productName, true);
+  const configToml = `[agents]
+max_threads = 6
+max_depth = 1
+job_max_runtime_seconds = 1800
+`;
+  const configPath = path.join(root, ".codex", "config.toml");
+  if (writeIfMissing(configPath, configToml)) created.push(".codex/config.toml");
+
+  const copiedPlatform = copyMirrorChildren(CODEX_MIRROR, path.join(root, ".codex"), {
+    skipNames: new Set(["agents"]),
+    reportRoot: root,
+  }).concat(copyCodexAgents(root));
+  const copiedSkills = copyCodexSkill(root).concat(copyRoleSkills(root), copyImpeccableSkill(root));
+  if (writePluginManifest(root)) created.push(".codex-plugin/plugin.json");
+  return [created, copiedPlatform, copiedSkills];
+}
+
+function createClaudeStructure(root, productName) {
+  const created = createCommonStructure(root, productName, false);
+  const copiedClaude = copyMirrorChildren(CLAUDE_MIRROR, path.join(root, ".claude"), {
+    reportRoot: root,
+  });
+  removeCodexAgentManifest(path.join(root, ".claude", "skills", "impeccable"));
+  return [created, copiedClaude, []];
+}
+
+function createStructure(rootInput, productName, cli) {
+  const root = path.resolve(rootInput);
+  ensureDir(root);
+  const hadPlatformMarker =
+    exists(path.join(root, ".claude")) || exists(path.join(root, ".codex")) || exists(path.join(root, ".agents"));
+  const selectedCli = detectCli(root, cli);
+
+  let created;
+  let copiedPlatform;
+  let copiedSkills;
+  let platformName;
+  let directorySummary;
+  let nextStep;
+
+  if (selectedCli === "claude") {
+    [created, copiedPlatform, copiedSkills] = createClaudeStructure(root, productName);
+    platformName = "Claude Code";
+    directorySummary = "docs/, prototype/, prototype/review/screenshots/, outputs/dev-package/, .claude/";
+    nextStep = "Next step: start Claude Code in this directory, then describe your product idea or run `/pm-workflow:init`.";
+  } else {
+    [created, copiedPlatform, copiedSkills] = createCodexStructure(root, productName);
+    platformName = "Codex";
+    directorySummary = "docs/, prototype/, prototype/review/screenshots/, outputs/dev-package/, .codex/, .agents/context/, .agents/skills/";
+    nextStep = "Next step: start Codex in this directory, then describe your product idea or say `澄清需求`.";
+  }
+
+  console.log(`Project structure created: ${root}`);
+  console.log(`Selected CLI structure: ${platformName}`);
+  if (cli === "auto" && selectedCli === "codex" && !hadPlatformMarker) {
+    console.log("Auto mode defaulted to Codex for an empty directory. Use `--ai claude` to create a Claude Code workspace.");
+  }
+  console.log(`Created or confirmed directories: ${directorySummary}`);
+
+  if (created.length) {
+    console.log("Template files created:");
+    for (const item of created) console.log(`  + ${item}`);
+  } else {
+    console.log("Template files already existed; no template files overwritten.");
+  }
+
+  if (copiedPlatform.length) {
+    console.log(`${platformName} platform files copied:`);
+    for (const item of copiedPlatform) console.log(`  + ${item}`);
+  } else {
+    console.log(`${platformName} platform files already existed or source package was unavailable.`);
+  }
+
+  if (copiedSkills.length) {
+    console.log("Repo-scoped skills copied:");
+    for (const item of copiedSkills) console.log(`  + ${item}`);
+  } else {
+    console.log("Repo-scoped skills already existed or not used by this CLI structure.");
+  }
+
+  console.log(nextStep);
+}
+
+function runInit(argv) {
+  const options = parseInitArgs(argv);
+  createStructure(options.root, options.name, options.ai);
+}
+
+function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  if (!command || command === "-h" || command === "--help") {
+    printHelp();
+    return;
+  }
+  if (command === "init") {
+    runInit(rest);
+    return;
+  }
+  fail(`unknown command "${command}".`);
+}
+
+main();

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "pm-workflow-studio",
+  "version": "0.1.0",
+  "description": "AI product development studio CLI for Codex and Claude Code.",
+  "type": "commonjs",
+  "bin": {
+    "pmflow": "bin/pmflow.js",
+    "pm-workflow": "bin/pmflow.js"
+  },
+  "files": [
+    "bin/",
+    ".codex/",
+    ".claude/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node bin/pmflow.js --help"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "keywords": [
+    "pm-workflow",
+    "product-management",
+    "codex",
+    "claude-code",
+    "ai-workflow"
+  ],
+  "license": "UNLICENSED"
+}