@jiraacp/cli 2026.405.4

package/dist/chunk-B6OA3XJK.js

@@ -0,0 +1,1167 @@
+import {
+  requestApproval,
+  requestClarification
+} from "./chunk-KSJKCLEJ.js";
+import {
+  acquireLock,
+  createTelegramNotifier
+} from "./chunk-WEJCTFQB.js";
+import {
+  StateManager,
+  getEvents,
+  getLockPath,
+  getMemoryDir,
+  getRunDir
+} from "./chunk-BM4R6NST.js";
+import {
+  createLogger,
+  initBot
+} from "./chunk-M4V3YOCY.js";
+
+// src/integrations/jira/client.ts
+import axios from "axios";
+function loadInstances() {
+  const instances = {};
+  for (const key of Object.keys(process.env)) {
+    const match = key.match(/^JIRA_([A-Z0-9]+)_URL$/);
+    if (!match) continue;
+    const name = match[1].toLowerCase();
+    const upper = match[1];
+    const url = process.env[`JIRA_${upper}_URL`];
+    const token = process.env[`JIRA_${upper}_TOKEN`];
+    const email = process.env[`JIRA_${upper}_EMAIL`];
+    if (url && token && email) {
+      instances[name] = { url, token, email };
+    }
+  }
+  return instances;
+}
+var INSTANCES = loadInstances();
+function getClient(instance) {
+  const config = INSTANCES[instance];
+  if (!config) {
+    const available = Object.keys(INSTANCES).join(", ") || "none";
+    throw new Error(
+      `Unknown Jira instance: "${instance}". Available: ${available}`
+    );
+  }
+  return axios.create({
+    baseURL: `${config.url}/rest/api/3`,
+    headers: {
+      Authorization: `Basic ${Buffer.from(`${config.email}:${config.token}`).toString("base64")}`,
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    }
+  });
+}
+
+// src/integrations/github/client.ts
+import { Octokit } from "@octokit/rest";
+function createGitHubClient(token, owner, repo) {
+  const octokit = new Octokit({ auth: token });
+  return {
+    async createBranch(base, branch) {
+      const { data: ref } = await octokit.git.getRef({
+        owner,
+        repo,
+        ref: `heads/${base}`
+      });
+      await octokit.git.createRef({
+        owner,
+        repo,
+        ref: `refs/heads/${branch}`,
+        sha: ref.object.sha
+      });
+    },
+    async createPR({ title, body, head, base, draft = false }) {
+      const { data } = await octokit.pulls.create({
+        owner,
+        repo,
+        title,
+        body,
+        head,
+        base,
+        draft
+      });
+      return data.number;
+    },
+    async mergePR(prNumber, strategy) {
+      const mergeMethod = strategy === "squash" ? "squash" : strategy === "rebase" ? "rebase" : "merge";
+      await octokit.pulls.merge({
+        owner,
+        repo,
+        pull_number: prNumber,
+        merge_method: mergeMethod
+      });
+    },
+    async addReviewers(prNumber, reviewers) {
+      if (reviewers.length === 0) return;
+      await octokit.pulls.requestReviewers({
+        owner,
+        repo,
+        pull_number: prNumber,
+        reviewers
+      });
+    },
+    async getPR(prNumber) {
+      const { data } = await octokit.pulls.get({
+        owner,
+        repo,
+        pull_number: prNumber
+      });
+      return { state: data.state, merged: data.merged };
+    },
+    async getRunStatus(branch) {
+      try {
+        const { data } = await octokit.repos.getCombinedStatusForRef({
+          owner,
+          repo,
+          ref: branch
+        });
+        if (data.state === "success") return "success";
+        if (data.state === "failure") return "failure";
+        return "pending";
+      } catch {
+        return "unknown";
+      }
+    }
+  };
+}
+
+// src/utils/pricing.ts
+var MODEL_PRICING = {
+  "claude-haiku-4-5": { inputPer1M: 0.8, outputPer1M: 4 },
+  "claude-sonnet-4-5": { inputPer1M: 3, outputPer1M: 15 },
+  "claude-opus-4-5": { inputPer1M: 15, outputPer1M: 75 },
+  "claude-haiku-4": { inputPer1M: 0.8, outputPer1M: 4 },
+  "claude-sonnet-4": { inputPer1M: 3, outputPer1M: 15 },
+  "claude-opus-4": { inputPer1M: 15, outputPer1M: 75 }
+};
+var DEFAULT_PRICING = { inputPer1M: 3, outputPer1M: 15 };
+function extractTokenUsage(output) {
+  if (typeof output !== "object" || output === null) return null;
+  const raw = output["tokenUsage"];
+  if (typeof raw !== "object" || raw === null) return null;
+  const tu = raw;
+  if (typeof tu["inputTokens"] !== "number" || typeof tu["outputTokens"] !== "number")
+    return null;
+  return {
+    inputTokens: tu["inputTokens"],
+    outputTokens: tu["outputTokens"],
+    model: typeof tu["model"] === "string" ? tu["model"] : "claude-sonnet-4"
+  };
+}
+function estimateCostUsd(inputTokens, outputTokens, model) {
+  const pricing = MODEL_PRICING[model] ?? DEFAULT_PRICING;
+  return inputTokens / 1e6 * pricing.inputPer1M + outputTokens / 1e6 * pricing.outputPer1M;
+}
+
+// src/pipeline/cost-guard.ts
+async function checkCostLimit(opts) {
+  const events = getEvents(opts.runDir);
+  let totalCost = 0;
+  for (const event of events) {
+    if (event.type !== "STAGE_COMPLETED") continue;
+    const tu = extractTokenUsage(event.output);
+    if (!tu) continue;
+    totalCost += estimateCostUsd(tu.inputTokens, tu.outputTokens, tu.model);
+  }
+  if (totalCost >= opts.maxCostUsd) {
+    await opts.telegram.send(
+      `\u26D4 <b>${opts.ticketKey}</b> \u2014 Cost limit reached ($${totalCost.toFixed(4)} / $${opts.maxCostUsd}). Aborting pipeline.`
+    );
+    return "abort";
+  }
+  if (totalCost >= 0.8 * opts.maxCostUsd) {
+    await opts.telegram.send(
+      `\u26A0\uFE0F <b>${opts.ticketKey}</b> \u2014 Cost at 80% of limit ($${totalCost.toFixed(4)} / $${opts.maxCostUsd}).`
+    );
+  }
+  return "continue";
+}
+
+// src/integrations/jira/tools.ts
+import { z } from "zod";
+var instanceSchema = z.string().describe('Instance name (e.g. "hi", "geo")');
+var GetTasksSchema = z.object({
+  instance: instanceSchema,
+  assignees: z.array(z.string()).describe("List of Jira usernames or accountIds"),
+  project_key: z.string().optional().describe('Filter by project key (e.g. "HI")'),
+  status: z.string().optional().describe('Filter by status (e.g. "In Progress")'),
+  max_results: z.number().default(20)
+});
+var GetTicketSchema = z.object({
+  instance: instanceSchema,
+  ticket_key: z.string().describe('Jira ticket key (e.g. "HI-123")')
+});
+var GetTransitionsSchema = z.object({
+  instance: instanceSchema,
+  ticket_key: z.string()
+});
+var TransitionTicketSchema = z.object({
+  instance: instanceSchema,
+  ticket_key: z.string(),
+  transition_name: z.string().describe('Transition name (e.g. "In Review", "Done")')
+});
+var AddCommentSchema = z.object({
+  instance: instanceSchema,
+  ticket_key: z.string(),
+  comment: z.string().describe("Comment text (plain text or Jira markdown)")
+});
+var ReassignSchema = z.object({
+  instance: instanceSchema,
+  ticket_key: z.string(),
+  account_id: z.string().describe("Jira accountId of the new assignee")
+});
+async function getTicket(args) {
+  const client = getClient(args.instance);
+  const { data } = await client.get(`/issue/${args.ticket_key}`);
+  return JSON.stringify(
+    {
+      key: data.key,
+      summary: data.fields.summary,
+      status: data.fields.status.name,
+      assignee: data.fields.assignee?.displayName ?? "Unassigned",
+      priority: data.fields.priority?.name,
+      description: extractText(data.fields.description),
+      acceptance_criteria: extractText(data.fields.customfield_10016),
+      created: data.fields.created,
+      updated: data.fields.updated
+    },
+    null,
+    2
+  );
+}
+async function transitionTicket(args) {
+  const client = getClient(args.instance);
+  const { data } = await client.get(`/issue/${args.ticket_key}/transitions`);
+  const transition = data.transitions.find(
+    (t) => t.name.toLowerCase() === args.transition_name.toLowerCase()
+  );
+  if (!transition) {
+    const available = data.transitions.map((t) => t.name).join(", ");
+    throw new Error(
+      `Transition "${args.transition_name}" not found. Available: ${available}`
+    );
+  }
+  await client.post(`/issue/${args.ticket_key}/transitions`, {
+    transition: { id: transition.id }
+  });
+  return `Transitioned ${args.ticket_key} to "${transition.name}"`;
+}
+async function addComment(args) {
+  const client = getClient(args.instance);
+  await client.post(`/issue/${args.ticket_key}/comment`, {
+    body: {
+      type: "doc",
+      version: 1,
+      content: [
+        { type: "paragraph", content: [{ type: "text", text: args.comment }] }
+      ]
+    }
+  });
+  return `Comment added to ${args.ticket_key}`;
+}
+async function reassign(args) {
+  const client = getClient(args.instance);
+  await client.put(`/issue/${args.ticket_key}/assignee`, {
+    accountId: args.account_id
+  });
+  return `${args.ticket_key} reassigned to accountId: ${args.account_id}`;
+}
+function extractText(adfNode) {
+  if (!adfNode) return "";
+  if (typeof adfNode === "string") return adfNode;
+  if (adfNode.type === "text") return adfNode.text ?? "";
+  if (adfNode.content) return adfNode.content.map(extractText).join(" ");
+  return "";
+}
+
+// src/memory/context-builder.ts
+import fs from "fs";
+import path from "path";
+function writeTicketContext(memoryDir, ticket) {
+  fs.mkdirSync(memoryDir, { recursive: true });
+  const content = `# Ticket: ${ticket.key}
+
+## Summary
+${ticket.summary}
+
+## Description
+${ticket.description || "(none)"}
+
+## Acceptance Criteria
+${ticket.acceptanceCriteria || "(none)"}
+
+## Priority
+${ticket.priority}
+${ticket.clarifications ? `
+## Clarifications from Team
+${ticket.clarifications}` : ""}
+`;
+  fs.writeFileSync(path.join(memoryDir, "ticket-context.md"), content);
+}
+function readTicketContext(memoryDir) {
+  const p = path.join(memoryDir, "ticket-context.md");
+  return fs.existsSync(p) ? fs.readFileSync(p, "utf8") : "";
+}
+function appendClarifications(memoryDir, answers) {
+  const p = path.join(memoryDir, "ticket-context.md");
+  if (fs.existsSync(p)) {
+    fs.appendFileSync(p, `
+## Clarifications from Team
+${answers}
+`);
+  }
+}
+function writeReviewFeedback(memoryDir, feedback) {
+  const lines = [
+    `# Review Results`,
+    `PR: #${feedback.prNumber}`,
+    `Major issues: ${feedback.issues.filter((i) => i.severity === "major").length}`,
+    `Minor issues: ${feedback.issues.filter((i) => i.severity === "minor").length}`,
+    `Auto-resolved: ${feedback.autoResolved}`,
+    "",
+    "## Issues",
+    ...feedback.issues.map(
+      (i) => `- [${i.severity.toUpperCase()}] ${i.message}`
+    )
+  ];
+  fs.writeFileSync(
+    path.join(memoryDir, "review-feedback.md"),
+    lines.join("\n")
+  );
+}
+function getContextFilesForStage(projectDir, memoryDir, stage) {
+  const claudeMd = path.join(projectDir, ".claude", "CLAUDE.md");
+  const ticketCtx = path.join(memoryDir, "ticket-context.md");
+  const reviewFeedback = path.join(memoryDir, "review-feedback.md");
+  const files = [];
+  if (fs.existsSync(claudeMd)) files.push(claudeMd);
+  if (["code", "git", "review", "deploy", "test", "notify"].includes(stage)) {
+    if (fs.existsSync(ticketCtx)) files.push(ticketCtx);
+  }
+  if (stage === "test" && fs.existsSync(reviewFeedback)) {
+    files.push(reviewFeedback);
+  }
+  return files;
+}
+
+// src/pipeline/stages/1-fetch.ts
+var fetchStage = {
+  id: "fetch",
+  name: "Fetch Ticket",
+  model: "haiku",
+  async run(ctx) {
+    const { config, ticketKey, memoryDir } = ctx;
+    ctx.logger.info({ ticketKey }, "Fetching ticket from Jira");
+    const raw = await getTicket({
+      instance: config.jira.instance,
+      ticket_key: ticketKey
+    });
+    const ticket = JSON.parse(raw);
+    writeTicketContext(memoryDir, {
+      key: ticket.key,
+      summary: ticket.summary,
+      description: ticket.description ?? "",
+      acceptanceCriteria: ticket.acceptance_criteria ?? "",
+      priority: ticket.priority ?? "Medium"
+    });
+    ctx.logger.info({ ticketKey, summary: ticket.summary }, "Ticket fetched");
+    return {
+      summary: ticket.summary,
+      description: ticket.description,
+      acceptanceCriteria: ticket.acceptance_criteria,
+      status: ticket.status
+    };
+  }
+};
+
+// src/utils/process.ts
+import { spawn } from "child_process";
+async function spawnSafe(bin, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(bin, args, {
+      cwd: opts.cwd,
+      env: opts.env ?? buildMinimalEnv(),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let stallTimer;
+    let globalTimer;
+    const resetStall = () => {
+      if (stallTimer) clearTimeout(stallTimer);
+      if (opts.stallTimeoutMs) {
+        stallTimer = setTimeout(() => {
+          proc.kill("SIGKILL");
+          reject(
+            new Error(
+              `Process stalled (no output for ${opts.stallTimeoutMs}ms)`
+            )
+          );
+        }, opts.stallTimeoutMs);
+      }
+    };
+    if (opts.timeoutMs) {
+      globalTimer = setTimeout(() => {
+        proc.kill("SIGKILL");
+        reject(new Error(`Process timed out after ${opts.timeoutMs}ms`));
+      }, opts.timeoutMs);
+    }
+    resetStall();
+    proc.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+      resetStall();
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("close", (code) => {
+      if (stallTimer) clearTimeout(stallTimer);
+      if (globalTimer) clearTimeout(globalTimer);
+      resolve({ stdout, stderr, exitCode: code ?? 1 });
+    });
+    proc.on("error", (err) => {
+      if (stallTimer) clearTimeout(stallTimer);
+      if (globalTimer) clearTimeout(globalTimer);
+      reject(err);
+    });
+  });
+}
+function buildMinimalEnv(extra = {}) {
+  return {
+    PATH: process.env["PATH"] ?? "",
+    HOME: process.env["HOME"] ?? "",
+    ANTHROPIC_API_KEY: process.env["ANTHROPIC_API_KEY"] ?? "",
+    ...extra
+  };
+}
+
+// src/pipeline/runner.ts
+var MODEL_IDS = {
+  haiku: "claude-haiku-4-5-20251001",
+  sonnet: "claude-sonnet-4-6",
+  opus: "claude-opus-4-6"
+};
+async function runAgent(opts) {
+  const args = [
+    "--model",
+    MODEL_IDS[opts.model],
+    "--print",
+    "--output-format",
+    "text"
+  ];
+  for (const f of opts.contextFiles ?? []) {
+    args.push("--context", f);
+  }
+  args.push(opts.prompt);
+  const result = await spawnSafe("claude", args, {
+    cwd: opts.workdir,
+    env: buildMinimalEnv(opts.extraEnv),
+    timeoutMs: opts.timeoutMs ?? 18e5,
+    stallTimeoutMs: opts.stallTimeoutMs ?? 3e5
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Agent exited with code ${result.exitCode}:
+${result.stderr}`
+    );
+  }
+  return result.stdout.trim();
+}
+async function runAgentsParallel(a, b) {
+  return Promise.all([runAgent(a), runAgent(b)]);
+}
+function detectComplexity(description) {
+  const complexKeywords = [
+    "auth",
+    "payment",
+    "stripe",
+    "oauth",
+    "jwt",
+    "migration",
+    "schema",
+    "database",
+    "refactor",
+    "cross-module",
+    "multi-service",
+    "security",
+    "encryption",
+    "permission"
+  ];
+  const lower = description.toLowerCase();
+  const matches = complexKeywords.filter((k) => lower.includes(k));
+  return matches.length >= 2 ? "opus" : "sonnet";
+}
+
+// src/pipeline/stages/2-analyze.ts
+var CLARITY_PROMPT = (ticketCtx, requiredFields) => `
+Analyze this Jira ticket for clarity. Score from 0.0 to 1.0.
+
+Required fields: ${requiredFields.join(", ")}
+
+Ticket:
+${ticketCtx}
+
+Reply with JSON only:
+{
+  "score": 0.0-1.0,
+  "missing": ["list of missing or ambiguous items"],
+  "questions": ["specific questions to ask the team"]
+}
+`.trim();
+var analyzeStage = {
+  id: "analyze",
+  name: "Analyze Clarity",
+  model: "sonnet",
+  async run(ctx) {
+    const { config, memoryDir, ticketKey } = ctx;
+    const ticketCtx = readTicketContext(memoryDir);
+    if (!ticketCtx)
+      throw new Error("ticket-context.md not found \u2014 run fetch stage first");
+    ctx.logger.info({ ticketKey }, "Analyzing ticket clarity");
+    const raw = await runAgent({
+      prompt: CLARITY_PROMPT(
+        ticketCtx,
+        config.jira.requiredFields ?? ["description", "acceptanceCriteria"]
+      ),
+      workdir: config.workspace.rootDir,
+      model: "haiku",
+      timeoutMs: 6e4,
+      stallTimeoutMs: 3e4
+    });
+    const jsonMatch = raw.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      ctx.logger.warn(
+        { ticketKey },
+        "Could not parse clarity JSON \u2014 defaulting to low score"
+      );
+      return { score: 0, missing: [], questions: [], needsClarification: true };
+    }
+    const result = JSON.parse(jsonMatch[0]);
+    const threshold = config.jira.clarityScoreThreshold ?? 0.7;
+    const needsClarification = result.score < threshold;
+    ctx.logger.info(
+      { ticketKey, score: result.score, threshold, needsClarification },
+      "Clarity analysis done"
+    );
+    return { ...result, needsClarification };
+  }
+};
+
+// src/pipeline/stages/3-clarify.ts
+import path2 from "path";
+var clarifyStage = {
+  id: "clarify",
+  name: "Clarify",
+  model: "haiku",
+  async shouldSkip(ctx) {
+    const lastAnalyze = ctx.state.current.completedStages.includes("analyze");
+    if (!lastAnalyze) return true;
+    const events = ctx.state.events;
+    const analyzeEvent = events.findLast(
+      (e) => e.type === "STAGE_COMPLETED" && e.stage === "analyze"
+    );
+    const output = analyzeEvent?.output;
+    return !output?.needsClarification;
+  },
+  async run(ctx) {
+    const { config, ticketKey, memoryDir } = ctx;
+    const storeDir = path2.join(config.workspace.rootDir, ".jira-acp");
+    const events = ctx.state.events;
+    const analyzeEvent = events.findLast(
+      (e) => e.type === "STAGE_COMPLETED" && e.stage === "analyze"
+    );
+    const questions = analyzeEvent?.output?.questions ?? ["Please clarify the ticket requirements."];
+    ctx.logger.info(
+      { ticketKey, questions },
+      "Requesting clarification via Telegram"
+    );
+    const hil = config.telegram.humanInTheLoop;
+    const answers = await requestClarification(
+      config.telegram.botToken,
+      config.telegram.chatId,
+      ticketKey,
+      questions,
+      storeDir,
+      {
+        timeoutMs: hil?.clarificationTimeoutMs ?? 36e5,
+        onTimeout: hil?.clarificationTimeoutAction ?? "skip"
+      }
+    );
+    appendClarifications(memoryDir, answers);
+    ctx.logger.info({ ticketKey }, "Clarifications received and saved");
+    return { clarified: true, answers };
+  }
+};
+
+// src/pipeline/stages/4-code.ts
+var codeStage = {
+  id: "code",
+  name: "Code",
+  model: "sonnet",
+  async run(ctx) {
+    const { config, ticketKey, memoryDir, projectDir } = ctx;
+    const ticketCtx = readTicketContext(memoryDir);
+    const contextFiles = getContextFilesForStage(projectDir, memoryDir, "code");
+    const model = detectComplexity(ticketCtx);
+    ctx.logger.info({ ticketKey, model }, "Starting code agent");
+    const branchName = buildBranchName(
+      config.github.branchPattern ?? "feature/{ticketKey}-{slug}",
+      ticketKey,
+      ticketCtx
+    );
+    const prompt = `
+Implement the following Jira ticket: ${ticketKey}
+
+Read the ticket context from the provided context files.
+
+Requirements:
+1. Create branch: ${branchName}
+2. Implement all acceptance criteria
+3. Write tests for new functionality
+4. Commit with message: "${ticketKey}: <short description>"
+5. Do NOT push \u2014 pipeline will handle git operations
+
+Branch naming: ${branchName}
+Workspace: ${config.workspace.rootDir}
+${config.workspace.buildCommand ? `Build command: ${config.workspace.buildCommand}` : ""}
+`.trim();
+    if (!ctx.dryRun) {
+      await runAgent({
+        prompt,
+        workdir: config.workspace.rootDir,
+        model,
+        contextFiles,
+        timeoutMs: config.pipeline?.stageTimeouts?.code ?? 18e5,
+        stallTimeoutMs: config.pipeline?.agentStallTimeoutMs ?? 3e5
+      });
+    }
+    ctx.logger.info({ ticketKey, branchName }, "Code agent completed");
+    return { branchName };
+  }
+};
+function buildBranchName(pattern, ticketKey, ticketCtx) {
+  const summaryLine = ticketCtx.split("\n").find((l) => l.startsWith("## Summary"));
+  const nextLine = summaryLine ? ticketCtx.split("\n")[ticketCtx.split("\n").indexOf(summaryLine) + 1] ?? "" : "";
+  const slug = nextLine.toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").slice(0, 40);
+  return pattern.replace("{ticketKey}", ticketKey).replace("{prefix}", "feature").replace("{slug}", slug || "implementation");
+}
+
+// src/pipeline/stages/5-git.ts
+var gitStage = {
+  id: "git",
+  name: "Git & PR",
+  model: "haiku",
+  async run(ctx) {
+    const { config, ticketKey, state } = ctx;
+    const branchName = state.current.branchName;
+    if (!branchName)
+      throw new Error("No branch name in state \u2014 code stage must run first");
+    const workdir = config.workspace.rootDir;
+    const ticketCtx = readTicketContext(ctx.memoryDir);
+    const summaryLine = ticketCtx.split("\n").find((l) => l.startsWith("## Summary"));
+    const summary = ticketCtx.split("\n")[ticketCtx.split("\n").indexOf(summaryLine ?? "") + 1] ?? ticketKey;
+    ctx.logger.info(
+      { ticketKey, branchName },
+      "Pushing branch and creating PR"
+    );
+    if (!ctx.dryRun) {
+      await spawnSafe("git", ["push", "origin", branchName], { cwd: workdir });
+      const prNumber = await ctx.github.createPR({
+        title: `[${ticketKey}] ${summary.trim()}`,
+        body: buildPrBody(ticketKey, ticketCtx),
+        head: branchName,
+        base: config.github.defaultBranch ?? "main",
+        draft: config.github.prDraftByDefault ?? false
+      });
+      if (config.github.reviewers?.length) {
+        await ctx.github.addReviewers(prNumber, config.github.reviewers);
+      }
+      ctx.logger.info({ ticketKey, prNumber }, "PR created");
+      return { branchName, prNumber };
+    }
+    return { branchName, prNumber: null };
+  }
+};
+function buildPrBody(ticketKey, ticketCtx) {
+  return `## ${ticketKey}
+
+${ticketCtx}
+
+---
+*Generated by jiraACP automated pipeline*`;
+}
+
+// src/pipeline/stages/6-review.ts
+var reviewStage = {
+  id: "review",
+  name: "Review",
+  model: "sonnet",
+  async run(ctx) {
+    const { config, ticketKey, state, memoryDir, projectDir } = ctx;
+    const prNumber = state.current.prNumber;
+    if (!prNumber)
+      throw new Error("No PR number in state \u2014 git stage must run first");
+    const contextFiles = getContextFilesForStage(
+      projectDir,
+      memoryDir,
+      "review"
+    );
+    ctx.logger.info({ ticketKey, prNumber }, "Running parallel review agents");
+    const logicPrompt = `Review PR #${prNumber} for ticket ${ticketKey}.
+Focus on: Does the implementation correctly satisfy the acceptance criteria?
+List issues as JSON: { "issues": [{ "severity": "minor"|"major", "message": "..." }] }`;
+    const qualityPrompt = `Review PR #${prNumber} for ticket ${ticketKey}.
+Focus on: Missing tests, security issues, type safety, performance red flags.
+List issues as JSON: { "issues": [{ "severity": "minor"|"major", "message": "..." }] }`;
+    const agentOpts = {
+      workdir: config.workspace.rootDir,
+      model: "sonnet",
+      contextFiles,
+      timeoutMs: (config.pipeline?.stageTimeouts?.review ?? 6e5) / 2,
+      stallTimeoutMs: 12e4
+    };
+    const [logicRaw, qualityRaw] = ctx.dryRun ? ['{"issues":[]}', '{"issues":[]}'] : await runAgentsParallel(
+      { ...agentOpts, prompt: logicPrompt },
+      { ...agentOpts, prompt: qualityPrompt }
+    );
+    const issues = [...parseIssues(logicRaw), ...parseIssues(qualityRaw)];
+    const majorCount = issues.filter((i) => i.severity === "major").length;
+    const threshold = config.github.majorIssueThreshold ?? 1;
+    const needsHumanApproval = majorCount >= threshold;
+    writeReviewFeedback(memoryDir, {
+      prNumber,
+      issues,
+      autoResolved: !needsHumanApproval
+    });
+    if (needsHumanApproval) {
+      ctx.logger.warn(
+        { ticketKey, majorCount },
+        "Major issues found \u2014 requesting human approval via Telegram"
+      );
+      ctx.state.emit({
+        type: "HUMAN_APPROVAL_REQUESTED",
+        context: { prNumber, majorCount }
+      });
+      const hil = config.telegram.humanInTheLoop;
+      const approved = ctx.dryRun ? true : await requestApproval(
+        config.telegram.botToken,
+        config.telegram.chatId,
+        ticketKey,
+        issues,
+        {
+          timeoutMs: hil?.reviewApprovalTimeoutMs ?? 864e5,
+          onTimeout: hil?.reviewApprovalTimeoutAction ?? "abort",
+          topicId: config.telegram.topicId
+        }
+      );
+      if (approved) {
+        ctx.state.emit({ type: "HUMAN_APPROVED" });
+        ctx.logger.info(
+          { ticketKey, prNumber },
+          "Human approved \u2014 proceeding to merge"
+        );
+      } else {
+        ctx.state.emit({
+          type: "HUMAN_REJECTED",
+          reason: "Reviewer rejected PR"
+        });
+        throw new Error(`REVIEW_REJECTED:PR #${prNumber} rejected by reviewer`);
+      }
+    }
+    if (!ctx.dryRun) {
+      await ctx.github.mergePR(
+        prNumber,
+        config.github.autoMergeStrategy ?? "squash"
+      );
+      ctx.logger.info({ ticketKey, prNumber }, "PR merged");
+    }
+    return { prNumber, issues, merged: true };
+  }
+};
+function parseIssues(raw) {
+  try {
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match) return [];
+    const parsed = JSON.parse(match[0]);
+    return (parsed.issues ?? []).map((i) => ({
+      severity: i.severity === "major" ? "major" : "minor",
+      message: i.message
+    }));
+  } catch {
+    return [];
+  }
+}
+
+// src/pipeline/stages/7-deploy.ts
+var deployStage = {
+  id: "deploy",
+  name: "Deploy",
+  model: "haiku",
+  async shouldSkip(ctx) {
+    return !ctx.config.deploy?.enabled;
+  },
+  async run(ctx) {
+    const { config, ticketKey } = ctx;
+    const deploy = config.deploy;
+    if (!deploy?.command) throw new Error("deploy.command not configured");
+    ctx.logger.info({ ticketKey }, "Deploying to dev server");
+    if (ctx.dryRun) return { deployed: false, dryRun: true };
+    const result = await spawnSafe(deploy.command, [], {
+      cwd: config.workspace.rootDir,
+      env: buildMinimalEnv(deploy.env ?? {}),
+      timeoutMs: deploy.timeoutMs ?? 12e5
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(
+        `Deploy failed (exit ${result.exitCode}):
+${result.stderr}`
+      );
+    }
+    if (deploy.healthCheckUrl) {
+      await healthCheck(
+        deploy.healthCheckUrl,
+        deploy.healthCheckTimeoutMs ?? 3e4
+      );
+    }
+    ctx.logger.info({ ticketKey }, "Deploy successful");
+    return { deployed: true, deployUrl: deploy.healthCheckUrl };
+  }
+};
+async function healthCheck(url, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(5e3) });
+      if (res.ok) return;
+    } catch {
+    }
+    await sleep(2e3);
+  }
+  throw new Error(`Health check timed out after ${timeoutMs}ms: ${url}`);
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// src/pipeline/stages/8-test.ts
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var testStage = {
+  id: "test",
+  name: "UI Test",
+  model: "sonnet",
+  async shouldSkip(ctx) {
+    return !ctx.config.test?.enabled;
+  },
+  async run(ctx) {
+    const { config, ticketKey, memoryDir, projectDir } = ctx;
+    const testConfig = config.test;
+    if (!testConfig?.baseUrl) throw new Error("test.baseUrl not configured");
+    const waitMs = testConfig.waitBeforeTestMs ?? 5e3;
+    ctx.logger.info({ ticketKey, waitMs }, "Waiting before UI tests");
+    await sleep2(waitMs);
+    const contextFiles = getContextFilesForStage(projectDir, memoryDir, "test");
+    const retries = testConfig.retries ?? 2;
+    const prompt = `
+Run Playwright UI tests for ticket ${ticketKey} on ${testConfig.baseUrl}.
+
+Test the acceptance criteria from the ticket context.
+Spec pattern: ${testConfig.specPattern ?? "e2e/**/*.spec.ts"}
+
+Report results as JSON: { "passed": boolean, "summary": "...", "failures": ["..."] }
+`.trim();
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        ctx.logger.info(
+          { ticketKey, attempt: attempt + 1 },
+          "Running UI tests"
+        );
+        const raw = ctx.dryRun ? '{"passed":true,"summary":"dry-run","failures":[]}' : await runAgent({
+          prompt,
+          workdir: config.workspace.rootDir,
+          model: "sonnet",
+          contextFiles,
+          timeoutMs: testConfig.timeoutMs ?? 3e5,
+          stallTimeoutMs: 6e4
+        });
+        const match = raw.match(/\{[\s\S]*\}/);
+        if (!match) throw new Error("Could not parse test results JSON");
+        const result = JSON.parse(match[0]);
+        if (result.passed) {
+          ctx.logger.info({ ticketKey }, "UI tests passed");
+          return { passed: true, summary: result.summary };
+        }
+        lastError = new Error(`Tests failed: ${result.failures.join(", ")}`);
+        ctx.logger.warn(
+          { ticketKey, attempt: attempt + 1, failures: result.failures },
+          "Tests failed, retrying"
+        );
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+      }
+    }
+    const failOnTest = config.pipeline?.failOnTestFailure ?? false;
+    if (failOnTest)
+      throw lastError ?? new Error("Tests failed after all retries");
+    await ctx.telegram.send(
+      `\u26A0\uFE0F <b>${ticketKey}</b> UI tests failed after ${retries + 1} attempts. Continuing pipeline.
+${lastError?.message}`
+    );
+    return { passed: false, summary: lastError?.message ?? "Tests failed" };
+  }
+};
+
+// src/pipeline/stages/9-notify.ts
+var notifyStage = {
+  id: "notify",
+  name: "Notify",
+  model: "haiku",
+  async run(ctx) {
+    const { config, ticketKey, state } = ctx;
+    const current = state.current;
+    ctx.logger.info({ ticketKey }, "Notifying: Jira + Telegram");
+    if (!ctx.dryRun) {
+      await transitionTicket({
+        instance: config.jira.instance,
+        ticket_key: ticketKey,
+        transition_name: config.jira.doneTransition ?? "Done"
+      });
+      const prInfo = current.prNumber ? `
+PR: #${current.prNumber}` : "";
+      const branchInfo = current.branchName ? `
+Branch: ${current.branchName}` : "";
+      await addComment({
+        instance: config.jira.instance,
+        ticket_key: ticketKey,
+        comment: `\u2705 Implemented via jiraACP automated pipeline.${prInfo}${branchInfo}
+
+All stages completed: fetch \u2192 analyze \u2192 code \u2192 review \u2192 deploy \u2192 test`
+      });
+      if (config.jira.reassignTo) {
+        await reassign({
+          instance: config.jira.instance,
+          ticket_key: ticketKey,
+          account_id: config.jira.reassignTo
+        });
+      }
+      await ctx.telegram.sendDone(ticketKey, {
+        summary: "Pipeline completed successfully",
+        prNumber: current.prNumber ?? void 0
+      });
+    }
+    ctx.logger.info({ ticketKey }, "Notifications sent");
+    return { notified: true };
+  }
+};
+
+// src/pipeline/hooks.ts
+var HookError = class extends Error {
+  constructor(hookName, exitCode) {
+    super(`Hook '${hookName}' failed with exit code ${exitCode}`);
+    this.hookName = hookName;
+    this.exitCode = exitCode;
+    this.name = "HookError";
+  }
+  hookName;
+  exitCode;
+};
+async function runHook(name, command, ctx) {
+  if (!command?.trim()) return;
+  const [bin, ...args] = command.trim().split(/\s+/);
+  const { logger } = ctx;
+  logger.info({ hookName: name, command }, "Running hook");
+  const result = await spawnSafe(bin, args, {
+    env: buildMinimalEnv({ JIRA_ACP_TICKET: ctx.ticketKey })
+  });
+  if (result.exitCode !== 0) {
+    logger.error(
+      { hookName: name, exitCode: result.exitCode, stderr: result.stderr },
+      "Hook failed"
+    );
+    throw new HookError(name, result.exitCode);
+  }
+  logger.info({ hookName: name }, "Hook completed");
+}
+
+// src/pipeline/orchestrator.ts
+var ALL_STAGES = [
+  fetchStage,
+  analyzeStage,
+  clarifyStage,
+  codeStage,
+  gitStage,
+  reviewStage,
+  deployStage,
+  testStage,
+  notifyStage
+];
+async function runPipeline(ticketKey, config, opts = {}) {
+  const projectDir = config.workspace.rootDir;
+  const runDir = getRunDir(config.name, ticketKey);
+  const lockPath = getLockPath(config.name, ticketKey);
+  const memoryDir = getMemoryDir(config.name, ticketKey);
+  const logger = createLogger(`pipeline:${ticketKey}`);
+  const state = new StateManager(runDir);
+  if (config.telegram?.botToken) {
+    await initBot(config.telegram.botToken);
+  }
+  const lock = await acquireLock(lockPath);
+  const ctx = {
+    config,
+    ticketKey,
+    projectDir,
+    state,
+    memoryDir,
+    dryRun: opts.dryRun ?? false,
+    logger,
+    jira: getClient(config.jira.instance),
+    github: createGitHubClient(
+      config.github.token,
+      config.github.owner,
+      config.github.repo
+    ),
+    telegram: createTelegramNotifier(
+      config.telegram.botToken,
+      config.telegram.chatId,
+      ticketKey,
+      config.name,
+      config.telegram.topicId
+    )
+  };
+  state.emit({ type: "STARTED", ticketKey });
+  const stages = filterStages(ALL_STAGES, opts.fromStage, opts.toStage);
+  const hooksConfig = config.pipeline?.hooks;
+  try {
+    await runHook("beforePipeline", hooksConfig?.beforePipeline, {
+      ticketKey,
+      logger
+    });
+    for (const stage of stages) {
+      if (await stage.shouldSkip?.(ctx)) {
+        state.emit({
+          type: "STAGE_SKIPPED",
+          stage: stage.id,
+          reason: "shouldSkip returned true"
+        });
+        logger.info({ stage: stage.id }, "Stage skipped");
+        await ctx.telegram.notifyStageSkipped(stage.id).catch(() => void 0);
+        continue;
+      }
+      if (stage.id === "code") {
+        await runHook("beforeCode", hooksConfig?.beforeCode, {
+          ticketKey,
+          logger
+        });
+      }
+      state.emit({ type: "STAGE_STARTED", stage: stage.id });
+      logger.info({ stage: stage.id }, `\u25B6 ${stage.name}`);
+      await ctx.telegram.notifyStageStarted(stage.id).catch(() => void 0);
+      try {
+        const timeout = config.pipeline?.stageTimeouts?.[stage.id];
+        const output = timeout ? await withTimeout(stage.run(ctx), timeout) : await stage.run(ctx);
+        state.emit({ type: "STAGE_COMPLETED", stage: stage.id, output });
+        logger.info({ stage: stage.id }, `\u2713 ${stage.name}`);
+        await ctx.telegram.notifyStageCompleted(stage.id).catch(() => void 0);
+        if (config.pipeline?.maxCostUsdPerRun) {
+          const decision = await checkCostLimit({
+            runDir,
+            maxCostUsd: config.pipeline.maxCostUsdPerRun,
+            telegram: ctx.telegram,
+            ticketKey
+          });
+          if (decision === "abort") {
+            state.emit({
+              type: "PIPELINE_ABORTED",
+              reason: "Cost limit exceeded"
+            });
+            throw new Error("Cost limit exceeded");
+          }
+        }
+        if (stage.id === "code") {
+          await runHook("afterCode", hooksConfig?.afterCode, {
+            ticketKey,
+            logger
+          });
+        }
+        if (stage.id === "deploy") {
+          await runHook("afterDeploy", hooksConfig?.afterDeploy, {
+            ticketKey,
+            logger
+          });
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.startsWith("SKIP:")) {
+          state.emit({
+            type: "STAGE_SKIPPED",
+            stage: stage.id,
+            reason: message
+          });
+          logger.warn({ stage: stage.id }, `Skipped: ${message}`);
+          return;
+        }
+        if (err instanceof HookError) {
+          state.emit({ type: "PIPELINE_ABORTED", reason: message });
+          throw err;
+        }
+        state.emit({ type: "STAGE_FAILED", stage: stage.id, error: message });
+        await ctx.telegram.notifyStageFailed(stage.id, message).catch(() => void 0);
+        throw err;
+      }
+    }
+    state.emit({ type: "PIPELINE_COMPLETED" });
+    logger.info({ ticketKey }, "Pipeline completed");
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    if (!(err instanceof HookError)) {
+      state.emit({ type: "PIPELINE_ABORTED", reason });
+    }
+    await ctx.telegram.sendError(ticketKey, err);
+    logger.error({ ticketKey, reason }, "Pipeline aborted");
+    process.exitCode = 1;
+  } finally {
+    await runHook("afterPipeline", hooksConfig?.afterPipeline, {
+      ticketKey,
+      logger
+    });
+    lock.release();
+  }
+}
+async function resumePipeline(ticketKey, config) {
+  const logger = createLogger(`pipeline:${ticketKey}`);
+  const state = new StateManager(getRunDir(config.name, ticketKey));
+  const current = state.current;
+  if (current.isCompleted) {
+    logger.info({ ticketKey }, "Pipeline already completed");
+    process.stdout.write(`Pipeline for ${ticketKey} already completed.
+`);
+    return;
+  }
+  const fromStage = current.currentStage ?? current.failedStage ?? "fetch";
+  logger.info({ ticketKey, fromStage }, "Resuming pipeline");
+  await runPipeline(ticketKey, config, { fromStage });
+}
+function filterStages(stages, from, to) {
+  const fromIdx = from ? stages.findIndex((s) => s.id === from) : 0;
+  const toIdx = to ? stages.findIndex((s) => s.id === to) : stages.length - 1;
+  return stages.slice(
+    fromIdx < 0 ? 0 : fromIdx,
+    toIdx < 0 ? stages.length : toIdx + 1
+  );
+}
+async function withTimeout(promise, ms) {
+  const signal = AbortSignal.timeout(ms);
+  const aborted = new Promise((_, reject) => {
+    signal.addEventListener("abort", () => {
+      reject(new Error(`Stage timed out after ${ms}ms`));
+    });
+  });
+  return Promise.race([promise, aborted]);
+}
+
+export {
+  runPipeline,
+  resumePipeline
+};
+//# sourceMappingURL=chunk-B6OA3XJK.js.map