specweave 0.28.17 → 0.28.20

package/plugins/specweave-github/lib/github-increment-sync-cli.js

@@ -0,0 +1,456 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "fs";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { IncrementIssueBuilder } from "./increment-issue-builder.js";
+import { execFileNoThrow } from "../../../src/utils/execFileNoThrow.js";
+async function loadGitHubConfig() {
+  const projectRoot = process.cwd();
+  const configPath = path.join(projectRoot, ".specweave/config.json");
+  let owner = process.env.GITHUB_OWNER || "";
+  let repo = process.env.GITHUB_REPO || "";
+  const token = process.env.GITHUB_TOKEN || "";
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (config.sync?.github?.owner && config.sync?.github?.repo) {
+        owner = config.sync.github.owner;
+        repo = config.sync.github.repo;
+      } else if (config.multiProject?.enabled && config.multiProject?.activeProject) {
+        const activeProject = config.multiProject.activeProject;
+        const projectConfig = config.multiProject.projects?.[activeProject];
+        if (projectConfig?.externalTools?.github?.repository) {
+          const parts = projectConfig.externalTools.github.repository.split("/");
+          if (parts.length === 2) {
+            owner = parts[0];
+            repo = parts[1];
+          }
+        }
+      } else if (config.sync?.activeProfile && config.sync?.profiles) {
+        const profile = config.sync.profiles[config.sync.activeProfile];
+        if (profile?.config?.owner && profile?.config?.repo) {
+          owner = profile.config.owner;
+          repo = profile.config.repo;
+        }
+      }
+    } catch (error) {
+      console.error("\u26A0\uFE0F  Failed to parse config.json:", error);
+    }
+  }
+  if (!owner || !repo) {
+    const result = await execFileNoThrow("git", ["remote", "get-url", "origin"]);
+    if (result.exitCode === 0 && result.stdout) {
+      const remoteUrl = result.stdout.trim();
+      const match = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
+      if (match) {
+        owner = owner || match[1];
+        repo = repo || match[2];
+      }
+    }
+  }
+  if (!token) {
+    console.error("\u274C GITHUB_TOKEN not set");
+    console.error("   Set it in .env file or export GITHUB_TOKEN=ghp_xxx");
+    return null;
+  }
+  if (!owner || !repo) {
+    console.error("\u274C Could not detect GitHub owner/repo");
+    console.error("   Set sync.github.owner and sync.github.repo in .specweave/config.json");
+    return null;
+  }
+  return { owner, repo, token };
+}
+async function findIncrementFolder(incrementId) {
+  const projectRoot = process.cwd();
+  const incrementsDir = path.join(projectRoot, ".specweave/increments");
+  if (!existsSync(incrementsDir)) {
+    return null;
+  }
+  const entries = await fs.readdir(incrementsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith("_")) continue;
+    if (entry.name === incrementId) {
+      return path.join(incrementsDir, entry.name);
+    }
+    if (entry.name.startsWith(incrementId + "-")) {
+      return path.join(incrementsDir, entry.name);
+    }
+  }
+  return null;
+}
+function loadExistingGitHubLinks(incrementPath) {
+  const metadataPath = path.join(incrementPath, "metadata.json");
+  if (!existsSync(metadataPath)) {
+    return { userStoryIssues: {} };
+  }
+  try {
+    const metadata = JSON.parse(readFileSync(metadataPath, "utf-8"));
+    return {
+      milestone: metadata.github?.milestone,
+      userStoryIssues: metadata.github?.userStoryIssues || {}
+    };
+  } catch {
+    return { userStoryIssues: {} };
+  }
+}
+async function updateIncrementMetadata(incrementPath, milestoneNumber, userStoryIssues) {
+  const metadataPath = path.join(incrementPath, "metadata.json");
+  let metadata = {};
+  if (existsSync(metadataPath)) {
+    try {
+      metadata = JSON.parse(readFileSync(metadataPath, "utf-8"));
+    } catch {
+    }
+  }
+  metadata.github = {
+    milestone: milestoneNumber,
+    userStoryIssues,
+    lastSync: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2) + "\n");
+}
+async function createOrGetMilestone(owner, repo, featureId, title, existingMilestone) {
+  if (existingMilestone) {
+    const verifyResult = await execFileNoThrow("gh", [
+      "api",
+      `repos/${owner}/${repo}/milestones/${existingMilestone}`,
+      "--jq",
+      ".number"
+    ]);
+    if (verifyResult.exitCode === 0) {
+      return {
+        number: existingMilestone,
+        url: `https://github.com/${owner}/${repo}/milestone/${existingMilestone}`
+      };
+    }
+  }
+  const searchResult = await execFileNoThrow("gh", [
+    "api",
+    `repos/${owner}/${repo}/milestones`,
+    "--jq",
+    `.[] | select(.title | contains("${featureId}")) | .number`
+  ]);
+  if (searchResult.exitCode === 0 && searchResult.stdout.trim()) {
+    const milestoneNumber2 = parseInt(searchResult.stdout.trim().split("\n")[0], 10);
+    return {
+      number: milestoneNumber2,
+      url: `https://github.com/${owner}/${repo}/milestone/${milestoneNumber2}`
+    };
+  }
+  const milestoneTitle = `[${featureId}] ${title}`;
+  const createResult = await execFileNoThrow("gh", [
+    "api",
+    `repos/${owner}/${repo}/milestones`,
+    "-X",
+    "POST",
+    "-f",
+    `title=${milestoneTitle}`,
+    "-f",
+    `description=Feature milestone for ${featureId}`,
+    "--jq",
+    ".number"
+  ]);
+  if (createResult.exitCode !== 0) {
+    throw new Error(`Failed to create milestone: ${createResult.stderr || createResult.stdout}`);
+  }
+  const milestoneNumber = parseInt(createResult.stdout.trim(), 10);
+  return {
+    number: milestoneNumber,
+    url: `https://github.com/${owner}/${repo}/milestone/${milestoneNumber}`
+  };
+}
+function buildUserStoryIssueBody(story, tasks, incrementData, githubRepo) {
+  const incrementId = incrementData.frontmatter.increment;
+  let body = "";
+  body += `**Feature**: ${incrementData.frontmatter.feature_id || "N/A"}
+`;
+  body += `**Status**: ${story.acceptanceCriteria.every((ac) => ac.completed) ? "complete" : "in-progress"}
+`;
+  body += `**Priority**: ${story.priority || incrementData.frontmatter.priority || "P2"}
+`;
+  body += `
+---
+
+`;
+  body += `## User Story
+
+`;
+  if (story.asA && story.iWant && story.soThat) {
+    body += `**As a** ${story.asA}
+`;
+    body += `**I want** ${story.iWant}
+`;
+    body += `**So that** ${story.soThat}
+
+`;
+  } else {
+    body += `${story.title}
+
+`;
+  }
+  body += `---
+
+`;
+  body += `## Acceptance Criteria
+
+`;
+  if (story.acceptanceCriteria.length > 0) {
+    const completed = story.acceptanceCriteria.filter((ac) => ac.completed).length;
+    const total = story.acceptanceCriteria.length;
+    const percentage = total > 0 ? Math.round(completed / total * 100) : 0;
+    body += `Progress: ${completed}/${total} criteria met (${percentage}%)
+
+`;
+    for (const ac of story.acceptanceCriteria) {
+      const checkbox = ac.completed ? "[x]" : "[ ]";
+      body += `- ${checkbox} **${ac.id}**: ${ac.description}
+`;
+    }
+    body += "\n";
+  } else {
+    body += `*No acceptance criteria defined*
+
+`;
+  }
+  body += `---
+
+`;
+  const storyTasks = tasks.filter(
+    (t) => t.userStories.includes(story.id) || t.userStories.some((us) => us.includes(story.id.replace("US-", "")))
+  );
+  if (storyTasks.length > 0) {
+    body += `## Implementation Tasks
+
+`;
+    const completedTasks = storyTasks.filter((t) => t.completed).length;
+    const totalTasks = storyTasks.length;
+    const taskPercentage = totalTasks > 0 ? Math.round(completedTasks / totalTasks * 100) : 0;
+    body += `Progress: ${completedTasks}/${totalTasks} tasks (${taskPercentage}%)
+
+`;
+    for (const task of storyTasks) {
+      const checkbox = task.completed ? "[x]" : "[ ]";
+      body += `- ${checkbox} **${task.id}**: ${task.title}
+`;
+    }
+    body += "\n";
+    body += `---
+
+`;
+  }
+  body += `## SpecWeave Increment
+
+`;
+  body += `**Increment**: [${incrementId}](https://github.com/${githubRepo}/tree/develop/.specweave/increments/${incrementId})
+
+`;
+  body += `---
+
+`;
+  body += `\u{1F916} Auto-synced by SpecWeave`;
+  return body;
+}
+async function syncUserStoryIssue(owner, repo, featureId, story, tasks, incrementData, milestoneNumber, existingIssueNumber) {
+  const title = `[${featureId}][${story.id}] ${story.title}`;
+  const body = buildUserStoryIssueBody(story, tasks, incrementData, `${owner}/${repo}`);
+  const labels = ["specweave", "user-story"];
+  const priority = story.priority?.toLowerCase() || incrementData.frontmatter.priority?.toLowerCase() || "p2";
+  labels.push(priority);
+  if (existingIssueNumber) {
+    const updateResult = await execFileNoThrow("gh", [
+      "issue",
+      "edit",
+      String(existingIssueNumber),
+      "--repo",
+      `${owner}/${repo}`,
+      "--title",
+      title,
+      "--body",
+      body
+    ]);
+    if (updateResult.exitCode !== 0) {
+      throw new Error(`Failed to update issue #${existingIssueNumber}: ${updateResult.stderr}`);
+    }
+    return {
+      number: existingIssueNumber,
+      url: `https://github.com/${owner}/${repo}/issues/${existingIssueNumber}`
+    };
+  }
+  const createArgs = [
+    "issue",
+    "create",
+    "--repo",
+    `${owner}/${repo}`,
+    "--title",
+    title,
+    "--body",
+    body,
+    "--milestone",
+    String(milestoneNumber)
+  ];
+  if (labels.length > 0) {
+    createArgs.push("--label", labels.join(","));
+  }
+  const createResult = await execFileNoThrow("gh", createArgs);
+  if (createResult.exitCode !== 0) {
+    throw new Error(`Failed to create issue: ${createResult.stderr || createResult.stdout}`);
+  }
+  const urlMatch = createResult.stdout.match(/https:\/\/github\.com\/[^\s]+\/issues\/(\d+)/);
+  if (!urlMatch) {
+    throw new Error("Could not parse issue URL from gh output");
+  }
+  return {
+    number: parseInt(urlMatch[1], 10),
+    url: urlMatch[0]
+  };
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    console.log("Usage: node github-increment-sync-cli.js <increment-id> [options]");
+    console.log("");
+    console.log("Creates GitHub issues with CORRECT format:");
+    console.log("  - Milestone: [FS-XXX] Feature Title");
+    console.log("  - Issues: [FS-XXX][US-YYY] User Story Title  (one per US)");
+    console.log("");
+    console.log("Arguments:");
+    console.log("  increment-id   Increment ID (e.g., 0002 or 0002-thumbnail-mvp)");
+    console.log("");
+    console.log("Options:");
+    console.log("  --dry-run      Preview issues without creating");
+    console.log("");
+    console.log("Environment:");
+    console.log("  GITHUB_TOKEN   Required - GitHub personal access token");
+    console.log("");
+    console.log("Example:");
+    console.log("  GITHUB_TOKEN=ghp_xxx node github-increment-sync-cli.js 0002");
+    process.exit(args.length === 0 ? 1 : 0);
+  }
+  const incrementId = args[0];
+  const dryRun = args.includes("--dry-run");
+  console.log(`
+\u{1F419} GitHub Increment Sync CLI (Per-User-Story Mode)`);
+  console.log(`   Increment: ${incrementId}`);
+  const incrementPath = await findIncrementFolder(incrementId);
+  if (!incrementPath) {
+    console.error(`\u274C Increment not found: ${incrementId}`);
+    console.error("   Check: ls .specweave/increments/");
+    process.exit(1);
+  }
+  const fullIncrementId = path.basename(incrementPath);
+  console.log(`   Found: ${fullIncrementId}`);
+  let config = null;
+  if (!dryRun) {
+    config = await loadGitHubConfig();
+    if (!config) {
+      process.exit(1);
+    }
+    console.log(`   Repository: ${config.owner}/${config.repo}`);
+  } else {
+    config = await loadGitHubConfig().catch(() => null);
+    if (config) {
+      console.log(`   Repository: ${config.owner}/${config.repo}`);
+    } else {
+      console.log(`   Repository: (not detected - dry run mode)`);
+    }
+  }
+  const projectRoot = process.cwd();
+  const builder = new IncrementIssueBuilder(incrementPath, projectRoot);
+  try {
+    console.log(`
+\u{1F504} Parsing increment spec.md...`);
+    const incrementData = await builder.parse();
+    const featureId = incrementData.frontmatter.feature_id || `FS-${fullIncrementId.match(/^(\d+)/)?.[1]?.padStart(3, "0") || "UNKNOWN"}`;
+    console.log(`   \u{1F4E6} Feature: ${featureId}`);
+    console.log(`   \u{1F4E6} Title: ${incrementData.title}`);
+    console.log(`   \u{1F4DD} User Stories: ${incrementData.userStories.length}`);
+    const totalACs = incrementData.userStories.reduce(
+      (sum, us) => sum + us.acceptanceCriteria.length,
+      0
+    );
+    console.log(`   \u2713 Acceptance Criteria: ${totalACs}`);
+    console.log(`   \u{1F527} Tasks: ${incrementData.tasks.length}`);
+    if (incrementData.userStories.length === 0) {
+      console.error(`
+\u274C No user stories found in spec.md`);
+      console.error("   Ensure spec.md has ### US-XXX: Title sections");
+      process.exit(1);
+    }
+    console.log(`
+\u{1F4CB} Issues to Create/Update:`);
+    console.log(`   \u{1F3AF} Milestone: [${featureId}] ${incrementData.title}`);
+    for (const story of incrementData.userStories) {
+      const storyTasks = incrementData.tasks.filter(
+        (t) => t.userStories.includes(story.id) || t.userStories.some((us) => us.includes(story.id.replace("US-", "")))
+      );
+      console.log(`   \u{1F4DD} [${featureId}][${story.id}] ${story.title}`);
+      console.log(`      \u2514\u2500 ${story.acceptanceCriteria.length} ACs, ${storyTasks.length} tasks`);
+    }
+    if (dryRun) {
+      console.log(`
+\u{1F4C4} Sample Issue Body (${incrementData.userStories[0].id}):
+`);
+      const sampleBody = buildUserStoryIssueBody(
+        incrementData.userStories[0],
+        incrementData.tasks,
+        incrementData,
+        config ? `${config.owner}/${config.repo}` : "owner/repo"
+      );
+      console.log(sampleBody);
+      console.log(`
+\u2705 Dry run complete (no issues created)`);
+      process.exit(0);
+    }
+    if (!config) {
+      console.error("\u274C GitHub config not available");
+      process.exit(1);
+    }
+    const existingLinks = loadExistingGitHubLinks(incrementPath);
+    console.log(`
+\u{1F3AF} Creating/updating milestone...`);
+    const milestone = await createOrGetMilestone(
+      config.owner,
+      config.repo,
+      featureId,
+      incrementData.title,
+      existingLinks.milestone
+    );
+    console.log(`   \u2705 Milestone #${milestone.number}: [${featureId}] ${incrementData.title}`);
+    console.log(`
+\u{1F4DD} Creating/updating user story issues...`);
+    const userStoryIssues = {};
+    for (const story of incrementData.userStories) {
+      const existingIssue = existingLinks.userStoryIssues[story.id];
+      const issue = await syncUserStoryIssue(
+        config.owner,
+        config.repo,
+        featureId,
+        story,
+        incrementData.tasks,
+        incrementData,
+        milestone.number,
+        existingIssue
+      );
+      userStoryIssues[story.id] = issue.number;
+      const action = existingIssue ? "\u267B\uFE0F  Updated" : "\u2705 Created";
+      console.log(`   ${action} #${issue.number}: [${featureId}][${story.id}] ${story.title}`);
+    }
+    await updateIncrementMetadata(incrementPath, milestone.number, userStoryIssues);
+    console.log(`
+\u{1F4DD} Metadata updated`);
+    console.log(`
+\u2705 Sync complete!`);
+    console.log(`   \u{1F3AF} Milestone: ${milestone.url}`);
+    console.log(`   \u{1F4DD} Issues: ${Object.keys(userStoryIssues).length} user stories synced`);
+    process.exit(0);
+  } catch (error) {
+    console.error(`
+\u274C Sync failed:`, error);
+    process.exit(1);
+  }
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});