issue-flow 0.3.0

package/dist/chunk-V356G3JS.js

@@ -0,0 +1,611 @@
+#!/usr/bin/env node
+import {
+  allStoriesPass,
+  clearLastError,
+  initializeState,
+  isoNow,
+  loadTaskPlan,
+  markIssueCompleted,
+  markIssueInProgress,
+  saveTaskPlan,
+  setLastError,
+  trimErrorMessage
+} from "./chunk-64FU2L2T.js";
+import {
+  applyPlaceholders,
+  loadPrompt
+} from "./chunk-OZVHOVDT.js";
+import {
+  getIcons,
+  getTermWidth,
+  printError,
+  printInfo,
+  printRetry,
+  printSuccess,
+  printWarning
+} from "./chunk-L7RIGFP6.js";
+
+// src/config.ts
+import { platform } from "os";
+import { join } from "path";
+
+// src/utils/shell.ts
+import { execa } from "execa";
+async function run(command, args = [], options) {
+  const result = await execa(command, args, {
+    reject: false,
+    ...options
+  });
+  return {
+    stdout: result.stdout?.toString() ?? "",
+    stderr: result.stderr?.toString() ?? "",
+    exitCode: result.exitCode ?? 1
+  };
+}
+
+// src/utils/git.ts
+async function getProjectRoot() {
+  const result = await run("git", ["rev-parse", "--show-toplevel"]);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      "Not inside a git repository. Please run issue-flow from within a git project."
+    );
+  }
+  return result.stdout.trim();
+}
+
+// src/config.ts
+var DEFAULTS = {
+  retryLimit: 10,
+  retryForever: false,
+  backoffBaseSeconds: 30,
+  backoffMaxSeconds: 900
+};
+function createConfig(options) {
+  return {
+    issueNumber: options.issueNumber,
+    maxIterations: options.maxIterations,
+    retryLimit: options.retryLimit ?? DEFAULTS.retryLimit,
+    retryForever: options.retryForever ?? DEFAULTS.retryForever,
+    backoffBaseSeconds: options.backoffBaseSeconds ?? DEFAULTS.backoffBaseSeconds,
+    backoffMaxSeconds: options.backoffMaxSeconds ?? DEFAULTS.backoffMaxSeconds
+  };
+}
+async function resolvePaths(config, scriptDir) {
+  const projectRoot = await getProjectRoot();
+  if (config.issueNumber) {
+    const issueDir = join(projectRoot, "issues", config.issueNumber);
+    return {
+      prdFile: join(issueDir, "tasks.json"),
+      progressFile: join(issueDir, "progress.txt"),
+      archiveDir: join(issueDir, "archive"),
+      lastBranchFile: join(issueDir, ".last-branch"),
+      projectRoot
+    };
+  }
+  const base = scriptDir ?? projectRoot;
+  return {
+    prdFile: join(base, "prd.json"),
+    progressFile: join(base, "progress.txt"),
+    archiveDir: join(base, "archive"),
+    lastBranchFile: join(base, ".last-branch"),
+    projectRoot
+  };
+}
+function getInstallHint(pkg) {
+  const os = platform();
+  if (os === "darwin") {
+    return `brew install ${pkg}`;
+  }
+  if (os === "linux") {
+    return `apt install ${pkg}  (or your distro's package manager)`;
+  }
+  if (os === "win32") {
+    return `winget install ${pkg}  (or choco install ${pkg})`;
+  }
+  return `install ${pkg} using your system package manager`;
+}
+async function validateDependencies() {
+  const errors = [];
+  const gitResult = await run("git", ["--version"]);
+  if (gitResult.exitCode !== 0) {
+    errors.push(`  - git  (install with: ${getInstallHint("git")})`);
+  }
+  const claudeResult = await run("claude", ["--version"]);
+  if (claudeResult.exitCode !== 0) {
+    errors.push("  - claude  (install with: npm install -g @anthropic-ai/claude-code)");
+  }
+  return errors;
+}
+
+// src/core/engine.ts
+import { existsSync } from "fs";
+import { cp, mkdir, readFile, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/ui/progress.ts
+import chalk from "chalk";
+function useColor() {
+  if (process.env.NO_COLOR === "1") return false;
+  if (!process.stdout.isTTY) return false;
+  return true;
+}
+function useUnicode() {
+  if (process.env.NO_COLOR === "1") return false;
+  if (!process.stdout.isTTY) return false;
+  return true;
+}
+function printProgressBar(passed, total) {
+  const barWidth = 20;
+  let pct = 0;
+  let filled = 0;
+  if (total > 0) {
+    pct = Math.floor(passed * 100 / total);
+    filled = Math.floor(passed * barWidth / total);
+  }
+  const empty = barWidth - filled;
+  const fillChar = useUnicode() ? "\u2588" : "#";
+  const emptyChar = useUnicode() ? "\u2591" : "-";
+  const bar = fillChar.repeat(filled) + emptyChar.repeat(empty);
+  const text = `${passed}/${total} (${pct}%)`;
+  if (useColor()) {
+    return `${chalk.green(bar)} ${text}`;
+  }
+  return `${bar} ${text}`;
+}
+function printIterationHeader(iteration, maxIter, stories) {
+  const icons = getIcons();
+  const colored = useColor();
+  const iterLabel = maxIter ? `Iteration ${iteration} of ${maxIter}` : `Iteration ${iteration}`;
+  const total = stories.length;
+  const passed = stories.filter((s) => s.passes).length;
+  console.log("");
+  if (colored) {
+    console.log(chalk.blue(`\u2501\u2501\u2501 ${icons.start} ${iterLabel} \u2501\u2501\u2501`));
+  } else {
+    console.log(`--- ${icons.start} ${iterLabel} ---`);
+  }
+  console.log("");
+  let foundFirstPending = false;
+  for (const story of stories) {
+    let icon;
+    let colorFn;
+    if (story.passes) {
+      icon = icons.success;
+      colorFn = colored ? chalk.green : (s) => s;
+    } else if (!foundFirstPending) {
+      icon = icons.pending;
+      colorFn = colored ? chalk.yellow : (s) => s;
+      foundFirstPending = true;
+    } else {
+      icon = icons.notReached;
+      colorFn = colored ? chalk.gray : (s) => s;
+    }
+    console.log(colorFn(`  ${icon} ${story.id}: ${story.title}`));
+  }
+  console.log("");
+  console.log(`  ${printProgressBar(passed, total)}`);
+}
+
+// src/ui/summary.ts
+import chalk2 from "chalk";
+function useColor2() {
+  if (process.env.NO_COLOR != null && process.env.NO_COLOR !== "") return false;
+  if (!process.stdout.isTTY) return false;
+  return true;
+}
+function useUnicode2() {
+  if (process.env.NO_COLOR != null && process.env.NO_COLOR !== "") return false;
+  if (!process.stdout.isTTY) return false;
+  return true;
+}
+function fitLine(text, width) {
+  if (text.length > width) {
+    return text.substring(0, width);
+  }
+  return text.padEnd(width);
+}
+function printBox(lines) {
+  const colored = useColor2();
+  const unicode = useUnicode2();
+  const termWidth = getTermWidth();
+  let maxContentWidth = 0;
+  for (const line of lines) {
+    if (line !== "---" && line.length > maxContentWidth) {
+      maxContentWidth = line.length;
+    }
+  }
+  const available = termWidth - 4;
+  if (maxContentWidth > available) {
+    maxContentWidth = available;
+  }
+  if (maxContentWidth < 20) {
+    maxContentWidth = 20;
+  }
+  const tl = unicode ? "\u256D" : "+";
+  const tr = unicode ? "\u256E" : "+";
+  const bl = unicode ? "\u2570" : "+";
+  const br = unicode ? "\u256F" : "+";
+  const h = unicode ? "\u2500" : "-";
+  const v = unicode ? "\u2502" : "|";
+  const sepL = unicode ? "\u251C" : "+";
+  const sepR = unicode ? "\u2524" : "+";
+  const hrule = h.repeat(maxContentWidth + 2);
+  const blue = colored ? chalk2.blue : (s) => s;
+  const _reset = (s) => s;
+  console.log(blue(`${tl}${hrule}${tr}`));
+  for (const line of lines) {
+    if (line === "---") {
+      console.log(blue(`${sepL}${hrule}${sepR}`));
+    } else {
+      const fitted = fitLine(line, maxContentWidth);
+      console.log(`${blue(v)} ${fitted} ${blue(v)}`);
+    }
+  }
+  console.log(blue(`${bl}${hrule}${br}`));
+}
+function printStartupHeader(config, plan) {
+  const icons = getIcons();
+  const storiesTotal = plan.userStories.length;
+  const storiesPassing = plan.userStories.filter((s) => s.passes).length;
+  const branchName = plan.branchName ?? "N/A";
+  const issueLabel = config.issueNumber ? `Issue #${config.issueNumber}` : "Standalone mode";
+  const maxIterLabel = config.maxIterations !== void 0 ? String(config.maxIterations) : "unlimited";
+  const retryLabel = config.retryForever ? "unlimited retries" : `${config.retryLimit} consecutive retries`;
+  printBox([
+    `${icons.start} Issue Flow`,
+    "---",
+    `Issue:       ${issueLabel}`,
+    `Branch:      ${branchName}`,
+    `Stories:     ${storiesPassing}/${storiesTotal} passing`,
+    `Iterations:  ${maxIterLabel}`,
+    `Retries:     ${retryLabel}`
+  ]);
+}
+function formatDuration(totalSeconds) {
+  const mins = Math.floor(totalSeconds / 60);
+  const secs = totalSeconds % 60;
+  if (mins > 0) {
+    return `${mins}m ${secs}s`;
+  }
+  return `${secs}s`;
+}
+function printSummaryBox(status, iterations, totalRetries, elapsedSeconds, plan, extraInfo) {
+  const icons = getIcons();
+  const storiesTotal = plan.userStories.length;
+  const storiesPassing = plan.userStories.filter((s) => s.passes).length;
+  const duration = formatDuration(elapsedSeconds);
+  let statusIcon;
+  let statusLabel;
+  switch (status) {
+    case "success":
+      statusIcon = icons.success;
+      statusLabel = "Completed";
+      break;
+    case "incomplete":
+      statusIcon = icons.warn;
+      statusLabel = "Incomplete";
+      break;
+    case "failed":
+      statusIcon = icons.fail;
+      statusLabel = "Failed";
+      break;
+  }
+  const boxLines = [
+    `${icons.end} Issue Flow Summary`,
+    "---",
+    `Status:      ${statusIcon} ${statusLabel}`,
+    `Stories:     ${storiesPassing}/${storiesTotal} passing`,
+    `Iterations:  ${iterations}`,
+    `Duration:    ${duration}`,
+    `Retries:     ${totalRetries}`
+  ];
+  if (extraInfo) {
+    boxLines.push("---");
+    boxLines.push(extraInfo);
+  }
+  console.log("");
+  printBox(boxLines);
+}
+
+// src/utils/retry.ts
+var TRANSIENT_PATTERNS = [
+  "timed out",
+  "timeout",
+  "connection reset",
+  "connection refused",
+  "connection aborted",
+  "network error",
+  "network unavailable",
+  "temporary failure",
+  "temporarily unavailable",
+  "service unavailable",
+  "overloaded",
+  "rate limit",
+  "too many requests",
+  "bad gateway",
+  "gateway timeout",
+  "internal server error",
+  "http 429",
+  "http 500",
+  "http 502",
+  "http 503",
+  "http 504",
+  "econnreset",
+  "econnrefused",
+  "enotfound",
+  "etimedout",
+  "socket hang up"
+];
+function isTransientFailure(exitCode, output) {
+  if (exitCode === 75) {
+    return true;
+  }
+  const lowered = output.toLowerCase();
+  return TRANSIENT_PATTERNS.some((pattern) => lowered.includes(pattern));
+}
+function retryDelaySeconds(attempt, baseSeconds = 30, maxSeconds = 900) {
+  const delay = baseSeconds * 2 ** (attempt - 1);
+  return Math.min(delay, maxSeconds);
+}
+
+// src/core/executor.ts
+import { execa as execa2 } from "execa";
+async function executeClaude(prompt) {
+  const result = await execa2("claude", ["--dangerously-skip-permissions", "--print"], {
+    input: prompt,
+    reject: false,
+    timeout: 0,
+    // No timeout — let the engine handle iteration limits
+    stripFinalNewline: false
+  });
+  const stdout = result.stdout?.toString() ?? "";
+  const stderr = result.stderr?.toString() ?? "";
+  const output = stdout + (stderr ? `
+${stderr}` : "");
+  if (output.trim()) {
+    process.stderr.write(`${output}
+`);
+  }
+  return {
+    exitCode: result.exitCode ?? 1,
+    output
+  };
+}
+
+// src/core/engine.ts
+function sleep(seconds) {
+  return new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+}
+async function ensureProgressFile(progressFile) {
+  if (!existsSync(progressFile)) {
+    const content = `# Issue Flow Progress Log
+Started: ${(/* @__PURE__ */ new Date()).toString()}
+---
+`;
+    await writeFile(progressFile, content, "utf-8");
+  }
+}
+async function archiveIfBranchChanged(plan, paths) {
+  const { lastBranchFile, archiveDir, prdFile, progressFile } = paths;
+  if (!existsSync(lastBranchFile)) {
+    return;
+  }
+  const currentBranch = plan.branchName ?? "";
+  let lastBranch = "";
+  try {
+    lastBranch = (await readFile(lastBranchFile, "utf-8")).trim();
+  } catch {
+    return;
+  }
+  if (currentBranch && lastBranch && currentBranch !== lastBranch) {
+    const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const folderName = lastBranch.replace(/^issue\//, "").replace(/[<>:"|?*\\]/g, "_");
+    const archiveFolder = join2(archiveDir, `${dateStr}-${folderName}`);
+    printInfo(`Archiving previous run: ${lastBranch}`);
+    await mkdir(archiveFolder, { recursive: true });
+    if (existsSync(prdFile)) {
+      await cp(prdFile, join2(archiveFolder, "tasks.json"));
+    }
+    if (existsSync(progressFile)) {
+      await cp(progressFile, join2(archiveFolder, "progress.txt"));
+    }
+    printInfo(`   Archived to: ${archiveFolder}`);
+    await writeFile(
+      progressFile,
+      `# Issue Flow Progress Log
+Started: ${(/* @__PURE__ */ new Date()).toString()}
+---
+`,
+      "utf-8"
+    );
+  }
+}
+async function trackBranch(plan, lastBranchFile) {
+  const branch = plan.branchName ?? "";
+  if (branch) {
+    await writeFile(lastBranchFile, `${branch}
+`, "utf-8");
+  }
+}
+async function runEngine(config, paths) {
+  if (!existsSync(paths.prdFile)) {
+    printError(`PRD file not found at ${paths.prdFile}`);
+    if (config.issueNumber) {
+      console.log(`Have you run the resolve-issue skill for issue #${config.issueNumber} first?`);
+    }
+    return 1;
+  }
+  let plan = await loadTaskPlan(paths.prdFile);
+  plan = initializeState(plan);
+  await saveTaskPlan(paths.prdFile, plan);
+  if (plan.issueStatus === "completed" && allStoriesPass(plan)) {
+    console.log(`Issue already marked complete in ${paths.prdFile}`);
+    return 0;
+  }
+  if (plan.issueStatus === "completed" && !allStoriesPass(plan)) {
+    printWarning(
+      "Issue marked completed but some stories are still pending. Resetting to in_progress."
+    );
+    plan = markIssueInProgress(plan);
+    plan = setLastError(
+      plan,
+      "invalid_completion_state",
+      "tasks.json claimed the issue was completed before every story had passes=true."
+    );
+    await saveTaskPlan(paths.prdFile, plan);
+  }
+  if (allStoriesPass(plan)) {
+    console.log("All user stories already pass. Marking issue as completed.");
+    plan = markIssueCompleted(plan);
+    await saveTaskPlan(paths.prdFile, plan);
+    return 0;
+  }
+  await archiveIfBranchChanged(plan, paths);
+  await trackBranch(plan, paths.lastBranchFile);
+  await ensureProgressFile(paths.progressFile);
+  const promptTemplate = await loadPrompt("execute");
+  printStartupHeader(config, plan);
+  const startTime = Date.now();
+  let i = 0;
+  let retryCount = 0;
+  let totalRetryCount = 0;
+  while (true) {
+    if (config.maxIterations !== void 0 && i >= config.maxIterations) {
+      break;
+    }
+    i++;
+    plan = await loadTaskPlan(paths.prdFile);
+    printIterationHeader(i, config.maxIterations, plan.userStories);
+    const prompt = applyPlaceholders(promptTemplate, {
+      __PRD_FILE__: paths.prdFile,
+      __PROGRESS_FILE__: paths.progressFile
+    });
+    const iterationStartedAt = isoNow();
+    plan = markIssueInProgress(plan, iterationStartedAt);
+    await saveTaskPlan(paths.prdFile, plan);
+    const result = await executeClaude(prompt);
+    if (result.exitCode !== 0) {
+      const errorMessage = trimErrorMessage(result.output);
+      if (isTransientFailure(result.exitCode, result.output)) {
+        retryCount++;
+        totalRetryCount++;
+        plan = await loadTaskPlan(paths.prdFile);
+        plan = setLastError(plan, "transient_claude_failure", errorMessage);
+        await saveTaskPlan(paths.prdFile, plan);
+        if (!config.retryForever && retryCount > config.retryLimit) {
+          const elapsed3 = Math.floor((Date.now() - startTime) / 1e3);
+          plan = await loadTaskPlan(paths.prdFile);
+          printSummaryBox(
+            "failed",
+            i,
+            totalRetryCount,
+            elapsed3,
+            plan,
+            `Exceeded retry limit (${config.retryLimit}) on transient errors`
+          );
+          return result.exitCode;
+        }
+        const delaySeconds = retryDelaySeconds(
+          retryCount,
+          config.backoffBaseSeconds,
+          config.backoffMaxSeconds
+        );
+        console.log("");
+        printRetry(
+          `Transient Claude failure on iteration ${i} (attempt ${retryCount}). Retrying in ${delaySeconds}s.`
+        );
+        i--;
+        await sleep(delaySeconds);
+        continue;
+      }
+      plan = await loadTaskPlan(paths.prdFile);
+      plan = setLastError(plan, "fatal_claude_failure", errorMessage);
+      await saveTaskPlan(paths.prdFile, plan);
+      const elapsed2 = Math.floor((Date.now() - startTime) / 1e3);
+      printSummaryBox(
+        "failed",
+        i,
+        totalRetryCount,
+        elapsed2,
+        plan,
+        `Claude CLI failed with exit code ${result.exitCode}`
+      );
+      return result.exitCode;
+    }
+    retryCount = 0;
+    plan = await loadTaskPlan(paths.prdFile);
+    plan = clearLastError(plan, iterationStartedAt);
+    await saveTaskPlan(paths.prdFile, plan);
+    if (result.output.includes("<promise>COMPLETE</promise>")) {
+      plan = await loadTaskPlan(paths.prdFile);
+      if (allStoriesPass(plan)) {
+        plan = markIssueCompleted(plan);
+        await saveTaskPlan(paths.prdFile, plan);
+        const elapsed2 = Math.floor((Date.now() - startTime) / 1e3);
+        printSummaryBox("success", i, totalRetryCount, elapsed2, plan);
+        return 0;
+      }
+      plan = setLastError(
+        plan,
+        "invalid_completion_signal",
+        "Claude returned <promise>COMPLETE</promise> before every story had passes=true."
+      );
+      await saveTaskPlan(paths.prdFile, plan);
+      console.log("");
+      printWarning(
+        "Claude returned a completion signal, but tasks.json still has pending stories. Ignoring completion and continuing."
+      );
+    }
+    printSuccess(`Iteration ${i} complete. Continuing...`);
+    await sleep(2);
+  }
+  const elapsed = Math.floor((Date.now() - startTime) / 1e3);
+  plan = await loadTaskPlan(paths.prdFile);
+  printSummaryBox(
+    "incomplete",
+    config.maxIterations ?? i,
+    totalRetryCount,
+    elapsed,
+    plan,
+    "Reached max iterations without completing all tasks."
+  );
+  return 1;
+}
+
+// src/commands/execute.ts
+async function runExecute(positionalMaxIter, options) {
+  const errors = await validateDependencies();
+  if (errors.length > 0) {
+    printError("The following required tools are not installed:");
+    for (const err of errors) {
+      console.log(err);
+    }
+    return 1;
+  }
+  const maxIterations = options.maxIterations ?? positionalMaxIter;
+  const config = createConfig({
+    issueNumber: options.issue,
+    maxIterations,
+    retryLimit: options.retryLimit,
+    retryForever: options.retryForever
+  });
+  const paths = await resolvePaths(config);
+  const exitCode = await runEngine(config, paths);
+  if (exitCode === 0 && config.issueNumber) {
+    try {
+      const plan = await loadTaskPlan(paths.prdFile);
+      if (allStoriesPass(plan)) {
+        plan.pipeline.executionCompleted = true;
+        await saveTaskPlan(paths.prdFile, plan);
+      }
+    } catch {
+    }
+  }
+  return exitCode;
+}
+
+export {
+  runExecute
+};
+//# sourceMappingURL=chunk-V356G3JS.js.map