automata-cli 0.1.0-bugfix-automata-deletion.94 → 0.1.0-feature-021-execute-command.127

package/README.md

@@ -99,6 +99,20 @@ See [docs/implement-next.md](docs/implement-next.md) for full details.
 
 ---
 
+## `automata execute`
+
+Delegate work to an AI executor (Claude or Codex) by providing a prompt inline, from a file, or via stdin.
+
+```bash
+automata execute --with claude --prompt "refactor the auth module"
+automata execute --with codex  --file-prompt prompts/fix.md
+echo "fix lint errors" | automata execute --with claude
+```
+
+See [docs/execute.md](docs/execute.md) for full details.
+
+---
+
 ## Development
 
 ### Prerequisites

package/dist/index.js

@@ -19,10 +19,12 @@ import React2 from "react";
 // src/config/ConfigWizard.tsx
 import { useState } from "react";
 import { Box, Text, useInput, useApp } from "ink";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
 
 // src/config/configStore.ts
 import { readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
+import { join, resolve as resolve2, sep } from "path";
 var DEFAULT_CLAUDE_SYSTEM_PROMPT = "You are an expert software engineer. Implement the following issue according to the project's existing conventions and style. Make minimal, targeted changes that satisfy the requirements. Run tests and linting before finishing.";
 var DEFAULT_FIX_COMMENTS_PROMPT = "You are an expert software engineer reviewing a pull request. Below are the open review comments left by reviewers on this PR. Please address each comment by making the appropriate code changes. Focus on the reviewer's concerns and make minimal, targeted changes that resolve each comment without altering unrelated code.";
 var DEFAULT_SONAR_PROMPT = "You are an expert software engineer. You have been given the URL of a SonarCloud analysis for this pull request. If the `sonar-quality-gate` skill is available in this repository, use it. The project is public, so use the SonarCloud REST API directly (no authentication required) rather than scraping the URL. Inspect both the quality gate and the list of issues for this pull request. If the quality gate fails because of duplication or another metric-based condition, use the relevant Sonar APIs to identify the affected files and details instead of relying only on the issues endpoint. Fix all new issues and quality-gate failures reported. Focus on code smells, bugs, vulnerabilities, and blocking quality-gate conditions flagged in this PR. Make targeted, minimal changes that resolve each issue without altering unrelated code.";
@@ -31,7 +33,32 @@ var CONFIG_FILE = "config.json";
 function configPath() {
   return join(process.cwd(), CONFIG_DIR, CONFIG_FILE);
 }
-function readConfig() {
+function automataDir() {
+  return join(process.cwd(), CONFIG_DIR);
+}
+function resolvePromptRef(value, dir) {
+  if (!value.endsWith(".md")) return value;
+  if (value.includes("/") || value.includes("\\")) {
+    throw new Error(`Prompt file "${value}" must be a plain filename with no subdirectories`);
+  }
+  const fullPath = resolve2(dir, value);
+  const safeBase = resolve2(dir) + sep;
+  if (!fullPath.startsWith(safeBase)) {
+    throw new Error(`Prompt file "${value}" resolves outside .automata/`);
+  }
+  try {
+    return readFileSync2(fullPath, "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      throw new Error(
+        `Prompt file "${value}" not found in "${dir}". Expected path: ${fullPath}`,
+        { cause: err }
+      );
+    }
+    throw err;
+  }
+}
+function readRawConfig() {
   try {
     const raw = readFileSync2(configPath(), "utf8");
     return JSON.parse(raw);
@@ -39,6 +66,26 @@ function readConfig() {
     return {};
   }
 }
+function readConfig() {
+  let config;
+  try {
+    const raw = readFileSync2(configPath(), "utf8");
+    config = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  const dir = automataDir();
+  if (config.claudeSystemPrompt) {
+    config.claudeSystemPrompt = resolvePromptRef(config.claudeSystemPrompt, dir);
+  }
+  if (config.prompts?.sonar) {
+    config.prompts.sonar = resolvePromptRef(config.prompts.sonar, dir);
+  }
+  if (config.prompts?.fixComments) {
+    config.prompts.fixComments = resolvePromptRef(config.prompts.fixComments, dir);
+  }
+  return config;
+}
 function writeConfig(config) {
   const dir = join(process.cwd(), CONFIG_DIR);
   mkdirSync(dir, { recursive: true });
@@ -47,6 +94,11 @@ function writeConfig(config) {
 
 // src/config/ConfigWizard.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
+function writePromptFile(filename, content) {
+  const dir = join2(process.cwd(), ".automata");
+  mkdirSync2(dir, { recursive: true });
+  writeFileSync2(join2(dir, filename), content, "utf8");
+}
 var REMOTE_OPTIONS = [
   { label: "GitHub", value: "gh" },
   { label: "Azure DevOps", value: "azdo" }
@@ -60,6 +112,7 @@ var MAIN_MENU_OPTIONS = ["Remote / Mode", "Implement-Next", "Prompts"];
 var PROMPTS_MENU_OPTIONS = ["Sonar", "Fix-Comments"];
 function ConfigWizard() {
   const existing = readConfig();
+  const rawExisting = readRawConfig();
   const initialRemoteIndex = REMOTE_OPTIONS.findIndex((o) => o.value === existing.remoteType);
   const initialTechIndex = TECHNIQUE_OPTIONS.findIndex((o) => o.value === existing.issueDiscoveryTechnique);
   const [screen, setScreen] = useState("main");
@@ -107,7 +160,7 @@ function ConfigWizard() {
         if (chosen.value === "gh") {
           setScreen("technique");
         } else {
-          writeConfig({ ...existing, remoteType: chosen.value });
+          writeConfig({ ...rawExisting, remoteType: chosen.value });
           exit();
         }
       } else if (key.escape) {
@@ -143,12 +196,17 @@ function ConfigWizard() {
       }
     } else if (screen === "system-prompt") {
       if (key.return) {
+        let claudeSystemPromptValue;
+        if (systemPrompt) {
+          writePromptFile("claude-system-prompt.md", systemPrompt);
+          claudeSystemPromptValue = "claude-system-prompt.md";
+        }
         writeConfig({
-          ...existing,
+          ...rawExisting,
           remoteType: pendingRemote,
           issueDiscoveryTechnique: pendingTechnique,
           issueDiscoveryValue: discoveryValue || void 0,
-          claudeSystemPrompt: systemPrompt || void 0
+          claudeSystemPrompt: claudeSystemPromptValue
         });
         exit();
       } else if (key.backspace || key.delete) {
@@ -179,10 +237,15 @@ function ConfigWizard() {
       }
     } else if (screen === "sonar-prompt") {
       if (key.return) {
-        const current = readConfig();
+        let sonarValue;
+        if (sonarPrompt) {
+          writePromptFile("sonar-prompt.md", sonarPrompt);
+          sonarValue = "sonar-prompt.md";
+        }
+        const current = readRawConfig();
         writeConfig({
           ...current,
-          prompts: { ...current.prompts, sonar: sonarPrompt || void 0 }
+          prompts: { ...current.prompts, sonar: sonarValue }
         });
         setScreen("prompts-menu");
       } else if (key.backspace || key.delete) {
@@ -196,10 +259,15 @@ function ConfigWizard() {
       }
     } else if (screen === "fix-comments-prompt") {
       if (key.return) {
-        const current = readConfig();
+        let fixCommentsValue;
+        if (fixCommentsPrompt) {
+          writePromptFile("fix-comments-prompt.md", fixCommentsPrompt);
+          fixCommentsValue = "fix-comments-prompt.md";
+        }
+        const current = readRawConfig();
         writeConfig({
           ...current,
-          prompts: { ...current.prompts, fixComments: fixCommentsPrompt || void 0 }
+          prompts: { ...current.prompts, fixComments: fixCommentsValue }
         });
         setScreen("prompts-menu");
       } else if (key.backspace || key.delete) {
@@ -338,7 +406,7 @@ var configSetType = new Command("type").description("Set the remote environment
 `);
     process.exit(1);
   }
-  const current = readConfig();
+  const current = readRawConfig();
   writeConfig({ ...current, remoteType: value });
   process.stdout.write(`Remote type set to: ${value}
 `);
@@ -349,19 +417,19 @@ var configSetIssueDiscoveryTechnique = new Command("issue-discovery-technique").
 `);
     process.exit(1);
   }
-  const current = readConfig();
+  const current = readRawConfig();
   writeConfig({ ...current, issueDiscoveryTechnique: value });
   process.stdout.write(`Issue discovery technique set to: ${value}
 `);
 });
 var configSetIssueDiscoveryValue = new Command("issue-discovery-value").description("Set the value for the issue discovery technique (label name, username, or search string)").argument("<value>", "The filter value").action((value) => {
-  const current = readConfig();
+  const current = readRawConfig();
   writeConfig({ ...current, issueDiscoveryValue: value });
   process.stdout.write(`Issue discovery value set to: ${value}
 `);
 });
 var configSetClaudeSystemPrompt = new Command("claude-system-prompt").description("Set the system prompt used when invoking Claude Code").argument("<value>", "System prompt text").action((value) => {
-  const current = readConfig();
+  const current = readRawConfig();
   writeConfig({ ...current, claudeSystemPrompt: value });
   process.stdout.write(`Claude system prompt set.
 `);
@@ -442,6 +510,8 @@ function getCurrentBranch() {
   }
   return stdout.trim();
 }
+var SONAR_FETCH_TIMEOUT_MS = 5e3;
+var SONAR_FAIL_CONCLUSIONS = /* @__PURE__ */ new Set(["FAILURE", "TIMED_OUT", "ACTION_REQUIRED", "CANCELLED"]);
 function parseOwnerRepo() {
   const { stdout, status } = run2("git", ["remote", "get-url", "origin"]);
   if (status !== 0) return null;
@@ -487,21 +557,314 @@ function extractSonarProjectKey(url) {
     return null;
   }
 }
-async function fetchSonarNewIssues(projectKey, prNumber) {
-  const apiUrl = `https://sonarcloud.io/api/issues/search?componentKeys=${encodeURIComponent(projectKey)}&pullRequest=${String(prNumber)}&resolved=false&ps=1`;
+function buildSonarPullRequestUrl(projectKey, prNumber) {
+  return `https://sonarcloud.io/summary/new_code?id=${encodeURIComponent(projectKey)}&pullRequest=${String(prNumber)}`;
+}
+function resolveSonarPullRequestUrl(url, prNumber) {
+  const projectKey = extractSonarProjectKey(url);
+  if (!projectKey) return url;
+  return buildSonarPullRequestUrl(projectKey, prNumber);
+}
+function isSonarUrl(url) {
+  try {
+    const hostname = new URL(url).hostname;
+    return hostname === "sonarcloud.io" || hostname.endsWith(".sonarcloud.io");
+  } catch {
+    return false;
+  }
+}
+function stripHtml(text) {
+  let stripped = "";
+  let inTag = false;
+  for (const char of text) {
+    if (char === "<") {
+      inTag = true;
+      stripped += " ";
+      continue;
+    }
+    if (char === ">") {
+      inTag = false;
+      continue;
+    }
+    if (!inTag) {
+      stripped += char;
+    }
+  }
+  return stripped;
+}
+function normalizeText(text) {
+  if (!text) return void 0;
+  const normalized = stripHtml(text).replaceAll(/\s+/g, " ").trim();
+  return normalized || void 0;
+}
+function resolveSonarPath(componentKey, components) {
+  if (!componentKey) return void 0;
+  const mapped = components.get(componentKey);
+  if (mapped) return mapped;
+  const separatorIndex = componentKey.indexOf(":");
+  if (separatorIndex === -1) return void 0;
+  const path = componentKey.slice(separatorIndex + 1).trim();
+  return path || void 0;
+}
+function mapSonarIssuesPage(data, targetIssues, components, rules) {
+  for (const component of data.components ?? []) {
+    if (component.key && component.path) {
+      components.set(component.key, component.path);
+    }
+  }
+  for (const rule of data.rules ?? []) {
+    if (!rule.key) continue;
+    const explanation = normalizeText(rule.htmlDesc) ?? normalizeText(rule.htmlNote) ?? normalizeText(rule.name);
+    if (explanation) {
+      rules.set(rule.key, explanation);
+    }
+  }
+  for (const issue of data.issues ?? []) {
+    if (!issue.key || !issue.message) continue;
+    const ruleKey = issue.rule;
+    const mappedIssue = {
+      key: issue.key,
+      severity: issue.severity,
+      type: issue.type,
+      message: issue.message,
+      path: resolveSonarPath(issue.component, components),
+      line: issue.line ?? issue.textRange?.startLine ?? null,
+      ...ruleKey ? { rule: ruleKey } : {},
+      ...ruleKey && rules.has(ruleKey) ? { explanation: rules.get(ruleKey) } : {}
+    };
+    targetIssues.push(mappedIssue);
+  }
+}
+function mapSonarHotspotsPage(data, targetHotspots, components) {
+  for (const component of data.components ?? []) {
+    if (component.key && component.path) {
+      components.set(component.key, component.path);
+    }
+  }
+  targetHotspots.push(...data.hotspots ?? []);
+}
+function mapSonarHotspot(hotspot, components, detail) {
+  const rule = detail?.rule;
+  return {
+    key: detail?.key ?? hotspot.key ?? "",
+    rule: hotspot.ruleKey ?? rule?.key ?? "",
+    ruleName: normalizeText(rule?.name),
+    status: detail?.status ?? hotspot.status ?? "UNKNOWN",
+    message: detail?.message ?? hotspot.message ?? "",
+    path: detail?.component?.path ?? resolveSonarPath(hotspot.component, components),
+    line: detail?.line ?? detail?.textRange?.startLine ?? hotspot.line ?? hotspot.textRange?.startLine ?? null,
+    securityCategory: rule?.securityCategory ?? hotspot.securityCategory,
+    vulnerabilityProbability: rule?.vulnerabilityProbability ?? hotspot.vulnerabilityProbability,
+    riskDescription: normalizeText(rule?.riskDescription),
+    vulnerabilityDescription: normalizeText(rule?.vulnerabilityDescription),
+    fixRecommendations: normalizeText(rule?.fixRecommendations)
+  };
+}
+async function fetchSonarJson(apiUrl) {
   const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 5e3);
+  const timeoutId = setTimeout(() => controller.abort(), SONAR_FETCH_TIMEOUT_MS);
   try {
     const response = await fetch(apiUrl, { signal: controller.signal });
-    if (!response.ok) return null;
-    const data = await response.json();
-    return data.paging?.total ?? null;
+    if (!response.ok) {
+      return { ok: false, status: response.status };
+    }
+    return {
+      ok: true,
+      status: response.status,
+      data: await response.json()
+    };
   } catch {
-    return null;
+    return { ok: false, status: null };
   } finally {
     clearTimeout(timeoutId);
   }
 }
+async function fetchSonarNewIssues(projectKey, prNumber, sonarcloudUrl) {
+  const apiUrl = `https://sonarcloud.io/api/issues/search?componentKeys=${encodeURIComponent(projectKey)}&pullRequest=${String(prNumber)}&resolved=false&ps=1`;
+  const response = await fetchSonarJson(apiUrl);
+  if (!response.ok) {
+    if (response.status === 401) {
+      return {
+        total: null,
+        note: `SonarCloud project is private. Open the Sonar URL in an authenticated browser: ${sonarcloudUrl}`
+      };
+    }
+    return {
+      total: null,
+      note: "SonarCloud new-issue count is unavailable right now."
+    };
+  }
+  if (typeof response.data.paging?.total === "number") {
+    return { total: response.data.paging.total };
+  }
+  return {
+    total: null,
+    note: "SonarCloud did not return a new-issue count for this pull request."
+  };
+}
+async function fetchSonarGateViolations(projectKey, prNumber) {
+  const apiUrl = `https://sonarcloud.io/api/qualitygates/project_status?projectKey=${encodeURIComponent(projectKey)}&pullRequest=${String(prNumber)}`;
+  const response = await fetchSonarJson(apiUrl);
+  if (!response.ok) {
+    return response;
+  }
+  const projectStatus = response.data.projectStatus;
+  const gateViolations = (projectStatus?.conditions ?? []).filter((condition) => condition.status !== void 0 && condition.status !== "OK").map((condition) => ({
+    metricKey: condition.metricKey ?? "unknown",
+    status: condition.status ?? "ERROR",
+    comparator: condition.comparator,
+    actualValue: condition.actualValue,
+    errorThreshold: condition.errorThreshold
+  }));
+  return {
+    ok: true,
+    status: response.status,
+    data: {
+      status: "available",
+      qualityGateStatus: projectStatus?.status,
+      gateViolations,
+      issues: [],
+      securityHotspots: []
+    }
+  };
+}
+async function fetchSonarIssues(projectKey, prNumber) {
+  const pageSize = 100;
+  const issues = [];
+  const components = /* @__PURE__ */ new Map();
+  const rules = /* @__PURE__ */ new Map();
+  let page = 1;
+  let total = null;
+  while (true) {
+    const apiUrl = `https://sonarcloud.io/api/issues/search?componentKeys=${encodeURIComponent(projectKey)}&pullRequest=${String(prNumber)}&resolved=false&ps=${String(pageSize)}&p=${String(page)}&additionalFields=_all`;
+    const response = await fetchSonarJson(apiUrl);
+    if (!response.ok) {
+      return response;
+    }
+    const paging = response.data.paging;
+    total ??= paging?.total ?? null;
+    mapSonarIssuesPage(response.data, issues, components, rules);
+    const fetchedCount = page * (paging?.pageSize ?? pageSize);
+    if (paging?.total === void 0 || fetchedCount >= paging.total) {
+      break;
+    }
+    page += 1;
+  }
+  return {
+    ok: true,
+    status: 200,
+    data: {
+      total,
+      issues
+    }
+  };
+}
+async function fetchSonarHotspotDetail(hotspotKey) {
+  const apiUrl = `https://sonarcloud.io/api/hotspots/show?hotspot=${encodeURIComponent(hotspotKey)}`;
+  return fetchSonarJson(apiUrl);
+}
+async function fetchSonarHotspots(projectKey, prNumber) {
+  const pageSize = 100;
+  const rawHotspots = [];
+  const components = /* @__PURE__ */ new Map();
+  let page = 1;
+  while (true) {
+    const apiUrl = `https://sonarcloud.io/api/hotspots/search?projectKey=${encodeURIComponent(projectKey)}&pullRequest=${String(prNumber)}&onlyMine=false&sinceLeakPeriod=true&ps=${String(pageSize)}&p=${String(page)}`;
+    const response = await fetchSonarJson(apiUrl);
+    if (!response.ok) {
+      return response;
+    }
+    const paging = response.data.paging;
+    mapSonarHotspotsPage(response.data, rawHotspots, components);
+    const fetchedCount = page * (paging?.pageSize ?? pageSize);
+    if (paging?.total === void 0 || fetchedCount >= paging.total) {
+      break;
+    }
+    page += 1;
+  }
+  const detailResults = await Promise.all(rawHotspots.map((hotspot) => fetchSonarHotspotDetail(hotspot.key ?? "")));
+  const securityHotspots = [];
+  for (let index = 0; index < rawHotspots.length; index += 1) {
+    const hotspot = rawHotspots[index];
+    const detailResult = detailResults[index];
+    if (detailResult && !detailResult.ok && detailResult.status === 401) {
+      return detailResult;
+    }
+    securityHotspots.push(mapSonarHotspot(hotspot, components, detailResult?.ok ? detailResult.data : void 0));
+  }
+  return {
+    ok: true,
+    status: 200,
+    data: securityHotspots
+  };
+}
+function sonarPrivateFailureSummary(sonarcloudUrl) {
+  return {
+    status: "private",
+    gateViolations: [],
+    issues: [],
+    securityHotspots: [],
+    privateMessage: `SonarCloud project is private. Open the Sonar URL in an authenticated browser: ${sonarcloudUrl}`
+  };
+}
+async function fetchSonarFailureSummary(projectKey, prNumber, sonarcloudUrl) {
+  const [gateResult, issuesResult, hotspotsResult] = await Promise.all([
+    fetchSonarGateViolations(projectKey, prNumber),
+    fetchSonarIssues(projectKey, prNumber),
+    fetchSonarHotspots(projectKey, prNumber)
+  ]);
+  if (!gateResult.ok && gateResult.status === 401) {
+    return {
+      summary: sonarPrivateFailureSummary(sonarcloudUrl),
+      issueTotal: null,
+      issueNote: `SonarCloud project is private. Open the Sonar URL in an authenticated browser: ${sonarcloudUrl}`
+    };
+  }
+  if (!issuesResult.ok && issuesResult.status === 401) {
+    return {
+      summary: sonarPrivateFailureSummary(sonarcloudUrl),
+      issueTotal: null,
+      issueNote: `SonarCloud project is private. Open the Sonar URL in an authenticated browser: ${sonarcloudUrl}`
+    };
+  }
+  if (!hotspotsResult.ok && hotspotsResult.status === 401) {
+    return {
+      summary: sonarPrivateFailureSummary(sonarcloudUrl),
+      issueTotal: null,
+      issueNote: `SonarCloud project is private. Open the Sonar URL in an authenticated browser: ${sonarcloudUrl}`
+    };
+  }
+  const gateViolations = gateResult.ok ? gateResult.data.gateViolations : [];
+  const issues = issuesResult.ok ? issuesResult.data.issues : [];
+  const securityHotspots = hotspotsResult.ok ? hotspotsResult.data : [];
+  const qualityGateStatus = gateResult.ok ? gateResult.data.qualityGateStatus : void 0;
+  const issueTotal = issuesResult.ok ? issuesResult.data.total : null;
+  const issueNote = issuesResult.ok ? void 0 : "SonarCloud new-issue count is unavailable right now.";
+  if (gateViolations.length === 0 && issues.length === 0 && securityHotspots.length === 0 && !qualityGateStatus) {
+    return {
+      summary: {
+        status: "unavailable",
+        gateViolations: [],
+        issues: [],
+        securityHotspots: [],
+        unavailableMessage: "SonarCloud failure details are unavailable right now."
+      },
+      issueTotal,
+      issueNote
+    };
+  }
+  return {
+    summary: {
+      status: "available",
+      qualityGateStatus,
+      gateViolations,
+      issues,
+      securityHotspots
+    },
+    issueTotal,
+    issueNote
+  };
+}
 async function getPrInfoGh(branch) {
   const { stdout, stderr, status } = run2("gh", [
     "pr",
@@ -517,12 +880,16 @@ async function getPrInfoGh(branch) {
     throw new Error(stderr.trim() || "Failed to query GitHub. Is `gh` installed and authenticated?");
   }
   const raw = JSON.parse(stdout);
-  const failedChecks = (raw.statusCheckRollup ?? []).filter(
+  const statusChecks = raw.statusCheckRollup ?? [];
+  const failedChecks = statusChecks.filter(
     (c) => c.conclusion !== null && ["FAILURE", "TIMED_OUT", "ACTION_REQUIRED", "CANCELLED"].includes(c.conclusion)
   );
-  const ownerRepo = failedChecks.length > 0 ? parseOwnerRepo() : null;
+  const sonarNeedsCheckRunOutput = statusChecks.some(
+    (c) => (isSonarUrl(c.detailsUrl) || c.name.toLowerCase().includes("sonar")) && !extractSonarProjectKey(c.detailsUrl)
+  );
+  const ownerRepo = failedChecks.length > 0 || sonarNeedsCheckRunOutput ? parseOwnerRepo() : null;
   const checkOutputs = ownerRepo ? fetchCheckRunOutputs(ownerRepo, raw.headRefOid) : /* @__PURE__ */ new Map();
-  const checks = (raw.statusCheckRollup ?? []).map((c) => {
+  const checks = statusChecks.map((c) => {
     const enriched = checkOutputs.get(c.name);
     return {
       name: c.name,
@@ -532,23 +899,28 @@ async function getPrInfoGh(branch) {
       detailsUrl: enriched?.detailsUrl || c.detailsUrl || ""
     };
   });
-  const sonarCheck = checks.find((c) => {
-    try {
-      const hostname = new URL(c.detailsUrl).hostname;
-      return hostname === "sonarcloud.io" || hostname.endsWith(".sonarcloud.io");
-    } catch {
-      return false;
-    }
-  });
+  const sonarCheck = checks.find((c) => isSonarUrl(c.detailsUrl));
   let sonarcloudUrl;
   let sonarNewIssues;
+  let sonarNewIssuesNote;
+  let sonarFailures;
   if (sonarCheck) {
-    sonarcloudUrl = sonarCheck.detailsUrl;
-    const projectKey = extractSonarProjectKey(sonarCheck.detailsUrl);
+    sonarcloudUrl = resolveSonarPullRequestUrl(sonarCheck.detailsUrl, raw.number);
+    const projectKey = extractSonarProjectKey(sonarcloudUrl);
     if (projectKey) {
-      sonarNewIssues = await fetchSonarNewIssues(projectKey, raw.number);
+      if (sonarCheck.conclusion !== null && SONAR_FAIL_CONCLUSIONS.has(sonarCheck.conclusion)) {
+        const sonarSummary = await fetchSonarFailureSummary(projectKey, raw.number, sonarcloudUrl);
+        sonarFailures = sonarSummary.summary;
+        sonarNewIssues = sonarSummary.issueTotal;
+        sonarNewIssuesNote = sonarSummary.issueNote;
+      } else {
+        const sonarNewIssuesResult = await fetchSonarNewIssues(projectKey, raw.number, sonarcloudUrl);
+        sonarNewIssues = sonarNewIssuesResult.total;
+        sonarNewIssuesNote = sonarNewIssuesResult.note;
+      }
     } else {
       sonarNewIssues = null;
+      sonarNewIssuesNote = "Could not determine the SonarCloud project key from the check URL.";
     }
   }
   return {
@@ -557,7 +929,8 @@ async function getPrInfoGh(branch) {
     state: raw.state,
     url: raw.url,
     checks,
-    ...sonarcloudUrl === void 0 ? {} : { sonarcloudUrl, sonarNewIssues }
+    ...sonarcloudUrl === void 0 ? {} : { sonarcloudUrl, sonarNewIssues, sonarNewIssuesNote },
+    ...sonarFailures === void 0 ? {} : { sonarFailures }
   };
 }
 async function getPrInfo2(branch) {
@@ -767,7 +1140,7 @@ function formatChecks(checks) {
   return lines.join("\n") + "\n";
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function isSonarCheck(check) {
   try {
@@ -789,6 +1162,109 @@ function formatFailedChecks(failed) {
   }
   return lines.join("\n") + "\n";
 }
+function formatGateViolation(violation) {
+  const parts = [sanitizeText(violation.metricKey)];
+  if (violation.actualValue) parts.push(`actual ${sanitizeText(violation.actualValue)}`);
+  if (violation.comparator && violation.errorThreshold) {
+    parts.push(`${sanitizeText(violation.comparator)} ${sanitizeText(violation.errorThreshold)}`);
+  } else if (violation.errorThreshold) {
+    parts.push(`threshold ${sanitizeText(violation.errorThreshold)}`);
+  }
+  return parts.join(" | ");
+}
+function formatLocation(path, line) {
+  if (!path) return void 0;
+  const safePath = sanitizeText(path);
+  if (!line) return safePath;
+  return `${safePath}:${String(line)}`;
+}
+function formatRuleWithName(rule, ruleName) {
+  const safeRule = sanitizeText(rule);
+  if (!ruleName) return safeRule;
+  return `${safeRule} (${sanitizeText(ruleName)})`;
+}
+function formatSonarIssue(issue) {
+  const lines = [`    - ${sanitizeText(issue.message)}`];
+  const location = formatLocation(issue.path, issue.line);
+  if (location) lines.push(`      Location: ${location}`);
+  if (issue.severity || issue.type) {
+    const labels = [issue.severity, issue.type].filter((label) => Boolean(label)).map(sanitizeText).join(" / ");
+    lines.push(`      Classification: ${labels}`);
+  }
+  if (issue.rule) lines.push(`      Rule: ${sanitizeText(issue.rule)}`);
+  if (issue.explanation) lines.push(`      Explanation: ${sanitizeText(issue.explanation)}`);
+  return lines;
+}
+function formatSonarHotspot(hotspot) {
+  const lines = [`    - ${sanitizeText(hotspot.message)}`];
+  const location = formatLocation(hotspot.path, hotspot.line);
+  if (location) lines.push(`      Location: ${location}`);
+  if (hotspot.status) lines.push(`      Status: ${sanitizeText(hotspot.status)}`);
+  if (hotspot.vulnerabilityProbability || hotspot.securityCategory) {
+    const labels = [hotspot.vulnerabilityProbability, hotspot.securityCategory].filter((label) => Boolean(label)).map(sanitizeText).join(" / ");
+    lines.push(`      Classification: ${labels}`);
+  }
+  if (hotspot.rule) {
+    lines.push(`      Rule: ${formatRuleWithName(hotspot.rule, hotspot.ruleName)}`);
+  }
+  if (hotspot.riskDescription) lines.push(`      Risk: ${sanitizeText(hotspot.riskDescription)}`);
+  if (hotspot.vulnerabilityDescription) lines.push(`      Review: ${sanitizeText(hotspot.vulnerabilityDescription)}`);
+  if (hotspot.fixRecommendations) lines.push(`      Fix: ${sanitizeText(hotspot.fixRecommendations)}`);
+  return lines;
+}
+function appendGateViolations(lines, gateViolations) {
+  if (gateViolations.length === 0) return;
+  lines.push("  Gate Violations:");
+  for (const violation of gateViolations) {
+    lines.push(`    - ${formatGateViolation(violation)}`);
+  }
+}
+function appendSonarIssues(lines, issues) {
+  if (issues.length === 0) return;
+  lines.push("  Issues:");
+  for (const issue of issues) {
+    lines.push(...formatSonarIssue(issue));
+  }
+}
+function appendSecurityHotspots(lines, securityHotspots) {
+  if (securityHotspots.length === 0) return;
+  lines.push("  Security Hotspots:");
+  for (const hotspot of securityHotspots) {
+    lines.push(...formatSonarHotspot(hotspot));
+  }
+}
+function hasSonarFailureDetails(sonarFailures) {
+  return Boolean(sonarFailures.qualityGateStatus) || sonarFailures.gateViolations.length > 0 || sonarFailures.issues.length > 0 || sonarFailures.securityHotspots.length > 0;
+}
+function formatSonarFailures(sonarFailures, sonarcloudUrl) {
+  const lines = ["Sonar Failures:"];
+  if (sonarFailures.status === "private") {
+    lines.push(`  Note: ${sanitizeText(sonarFailures.privateMessage ?? "SonarCloud project is private.")}`);
+    return lines.join("\n") + "\n";
+  }
+  if (sonarFailures.status === "unavailable") {
+    lines.push(`  Note: ${sanitizeText(sonarFailures.unavailableMessage ?? "SonarCloud failure details are unavailable.")}`);
+    if (sonarcloudUrl) lines.push(`  URL:  ${sonarcloudUrl}`);
+    return lines.join("\n") + "\n";
+  }
+  if (sonarFailures.qualityGateStatus) {
+    lines.push(`  Quality Gate: ${sanitizeText(sonarFailures.qualityGateStatus)}`);
+  }
+  appendGateViolations(lines, sonarFailures.gateViolations);
+  appendSonarIssues(lines, sonarFailures.issues);
+  appendSecurityHotspots(lines, sonarFailures.securityHotspots);
+  if (!hasSonarFailureDetails(sonarFailures)) {
+    lines.push("  Note: SonarCloud reported a failure but returned no violation, issue, or hotspot details.");
+    if (sonarcloudUrl) lines.push(`  URL:  ${sonarcloudUrl}`);
+  }
+  return lines.join("\n") + "\n";
+}
+function sonarFailureNote(sonarFailures) {
+  if (!sonarFailures) return void 0;
+  if (sonarFailures.status === "private") return sonarFailures.privateMessage;
+  if (sonarFailures.status === "unavailable") return sonarFailures.unavailableMessage;
+  return void 0;
+}
 var POLL_INTERVAL_MS = 1e4;
 var getPrInfoCmd = new Command2("get-pr-info").description("Show pull request info for the current branch").option("--json", "Output as JSON").option("--wait-finish-checks", "Poll until all checks complete, then print the normal get-pr-info output").addHelpText(
   "after",
@@ -858,12 +1334,20 @@ URL:   ${pr.url}
       const issueStr = pr.sonarNewIssues === null || pr.sonarNewIssues === void 0 ? "unavailable" : String(pr.sonarNewIssues);
       process.stdout.write(`Sonar New Issues: ${issueStr}
 `);
+      const failureNote = sonarFailureNote(pr.sonarFailures);
+      if (pr.sonarNewIssuesNote && pr.sonarNewIssuesNote !== failureNote) {
+        process.stdout.write(`Sonar Note: ${sanitizeText(pr.sonarNewIssuesNote)}
+`);
+      }
     }
     process.stdout.write(formatCheckSummary(pr.checks));
     process.stdout.write(formatChecks(pr.checks));
     if (failed.length > 0) {
       process.stdout.write(formatFailedChecks(failed));
     }
+    if (pr.sonarFailures !== void 0) {
+      process.stdout.write(formatSonarFailures(pr.sonarFailures, pr.sonarcloudUrl));
+    }
   }
 });
 var ANSI_ESCAPE_RE = new RegExp("\x1B(?:[@-Z\\\\-_]|\\[[0-?]*[ -/]*[@-~])", "g");
@@ -1075,6 +1559,7 @@ minor segment is incremented (e.g. 1.2.0 \u2192 1.3.0).`
 var gitCommand = new Command2("git").description("Git workflow commands (some require gh CLI)").addCommand(getPrInfoCmd).addCommand(getPrCommentsCmd).addCommand(finishFeatureCmd).addCommand(publishReleaseCmd);
 
 // src/commands/getReady.ts
+import { createInterface as createInterface2 } from "readline";
 import { Command as Command3 } from "commander";
 
 // src/config/githubService.ts
@@ -1094,14 +1579,14 @@ function run3(cmd, args) {
     status: result.status ?? 1
   };
 }
-function listIssues(technique, value) {
+function listIssues(technique, value, limit = 10) {
   const baseArgs = [
     "issue",
     "list",
     "--state",
     "open",
     "--limit",
-    "1",
+    String(limit),
     "--json",
     "number,title,body,url"
   ];
@@ -1121,11 +1606,7 @@ function listIssues(technique, value) {
   if (status !== 0) {
     throw new Error(stderr.trim() || "Failed to query GitHub issues. Is `gh` installed and authenticated?");
   }
-  const issues = JSON.parse(stdout);
-  if (issues.length === 0) {
-    return null;
-  }
-  return issues[0];
+  return JSON.parse(stdout);
 }
 function postComment(issueNumber, body) {
   const { stderr, status } = run3("gh", ["issue", "comment", String(issueNumber), "--body", body]);
@@ -1138,7 +1619,7 @@ function postComment(issueNumber, body) {
 import { spawn, spawnSync as spawnSync4 } from "child_process";
 import { createInterface } from "readline";
 import { existsSync } from "fs";
-import { delimiter, join as join2 } from "path";
+import { delimiter, join as join3 } from "path";
 
 // src/cli/spawnUtils.ts
 function truncate(str, max) {
@@ -1173,7 +1654,7 @@ function handleExitCode(status, toolName) {
 function resolveCommand(name) {
   const pathDirs = (process.env["PATH"] ?? "").split(delimiter);
   for (const dir of pathDirs) {
-    const candidate = join2(dir, name);
+    const candidate = join3(dir, name);
     if (existsSync(candidate)) return candidate;
   }
   return name;
@@ -1209,7 +1690,7 @@ function invokeClaudeCodeSync(prompt, yolo, model) {
   handleExitCode(result.status, "Claude Code");
 }
 function invokeClaudeCodeVerbose(prompt, yolo, model) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const claudeBin = resolveCommand("claude");
     const args = [];
     if (yolo) args.push("--dangerously-skip-permissions");
@@ -1231,7 +1712,7 @@ function invokeClaudeCodeVerbose(prompt, yolo, model) {
     });
     child.on("close", (code) => {
       handleExitCode(code, "Claude Code");
-      resolve2();
+      resolve3();
     });
   });
 }
@@ -1305,12 +1786,13 @@ function invokeCodexCode(prompt, options = {}) {
   if (options.verbose) {
     process.stderr.write("Warning: --verbose is not supported for Codex and will be ignored.\n");
   }
-  invokeCodexCodeSync(prompt, options.yolo ?? false);
+  invokeCodexCodeSync(prompt, options.yolo ?? false, options.model);
 }
-function invokeCodexCodeSync(prompt, yolo) {
+function invokeCodexCodeSync(prompt, yolo, model) {
   const codexBin = resolveCommand("codex");
   const args = ["exec"];
   if (yolo) args.push("--dangerously-bypass-approvals-and-sandbox");
+  if (model) args.push("--model", model);
   args.push(prompt);
   const result = spawnSync5(codexBin, args, { encoding: "utf8", stdio: "inherit" });
   handleSpawnError(result.error, "codex");
@@ -1318,8 +1800,37 @@ function invokeCodexCodeSync(prompt, yolo) {
 }
 
 // src/commands/getReady.ts
-var implementNextCommand = new Command3("implement-next").description("Find the next open GitHub issue matching the configured filter, claim it, and invoke the AI code assistant (Claude or Codex)").option("--json", "Output issue details as JSON").option("--no-claude", "Skip all AI invocation (Claude or Codex) after claiming the issue").option("--codex", "Use Codex CLI instead of Claude Code").option("--query-only", "Print issue content and exit without claiming or invoking any AI tools").option("--yolo", "Launch with --dangerously-skip-permissions (Claude) or --dangerously-bypass-approvals-and-sandbox (Codex)").option("--verbose", "Show step-by-step progress summary and final result").option("--opus", "Use claude-opus-4-6").option("--sonnet", "Use claude-sonnet-4-6").option("--haiku", "Use claude-haiku-4-5-20251001").action(async (options) => {
-  const config = readConfig();
+function writeOverflowHint(output, issues, limit) {
+  if (issues.length === limit) {
+    output.write(`(Showing first ${limit} matching issues \u2014 there may be more. Use --limit to fetch more.)
+`);
+  }
+}
+function writeIssueList(output, issues, limit) {
+  output.write("\nAvailable issues:\n");
+  for (let i = 0; i < issues.length; i++) {
+    output.write(`  [${i + 1}] #${issues[i].number} - ${issues[i].title}
+`);
+  }
+  writeOverflowHint(output, issues, limit);
+}
+async function promptSelection(issues, limit, output) {
+  writeIssueList(output, issues, limit);
+  const rl = createInterface2({ input: process.stdin, output });
+  const answer = await new Promise(
+    (resolve3) => rl.question(`
+Select issue (1-${issues.length}): `, resolve3)
+  );
+  rl.close();
+  const n = Number.parseInt(answer.trim(), 10);
+  if (Number.isNaN(n) || n < 1 || n > issues.length) {
+    process.stderr.write(`Error: Invalid selection "${answer.trim()}". Enter a number between 1 and ${issues.length}.
+`);
+    process.exit(1);
+  }
+  return issues[n - 1];
+}
+function validateConfig(config) {
   if (config.remoteType !== "gh") {
     process.stderr.write(
       "Error: implement-next is not supported in Azure DevOps mode. Work item discovery is not available in azdo-cli. See docs/azdo-gap.md for details.\n"
@@ -1338,24 +1849,58 @@ var implementNextCommand = new Command3("implement-next").description("Find the
     );
     process.exit(1);
   }
+}
+async function resolveIssue(issues, options, limit) {
+  const selectionOutput = options.json ? process.stderr : process.stdout;
+  if (issues.length === 0) {
+    process.stdout.write("No issues found matching the configured filter.\n");
+    process.exit(0);
+  }
+  if (issues.length > 1 && options.queryOnly) {
+    writeIssueList(selectionOutput, issues, limit);
+    process.exit(0);
+  }
   let issue;
+  if (issues.length === 1) {
+    issue = issues[0];
+    selectionOutput.write(`Issue:  #${issue.number}
+Title:  ${issue.title}
+`);
+  } else if (options.takeFirst) {
+    issue = issues[0];
+    selectionOutput.write(`Selecting issue #${issue.number}: ${issue.title}
+`);
+  } else {
+    issue = await promptSelection(issues, limit, selectionOutput);
+    selectionOutput.write(`
+Issue:  #${issue.number}
+Title:  ${issue.title}
+`);
+  }
+  return issue;
+}
+var implementNextCommand = new Command3("implement-next").description("Find the next open GitHub issue matching the configured filter, claim it, and invoke the AI code assistant (Claude or Codex)").option("--json", "Output issue details as JSON").option("--no-claude", "Skip all AI invocation (Claude or Codex) after claiming the issue").option("--codex", "Use Codex CLI instead of Claude Code").option("--query-only", "Print issue content and exit without claiming or invoking any AI tools").option("--yolo", "Launch with --dangerously-skip-permissions (Claude) or --dangerously-bypass-approvals-and-sandbox (Codex)").option("--verbose", "Show step-by-step progress summary and final result").option("--opus", "Use claude-opus-4-6").option("--sonnet", "Use claude-sonnet-4-6").option("--haiku", "Use claude-haiku-4-5-20251001").option("--take-first", "When multiple issues match, pick the first without prompting").option("--limit <n>", "Max issues to fetch and display (default: 10)", "10").action(async (options) => {
+  const config = readConfig();
+  validateConfig(config);
+  const limit = Number.parseInt(options.limit, 10);
+  if (Number.isNaN(limit) || limit <= 0) {
+    process.stderr.write(`Error: --limit must be a positive integer (got "${options.limit}").
+`);
+    process.exit(1);
+  }
+  let issues;
   try {
-    issue = listIssues(config.issueDiscoveryTechnique, config.issueDiscoveryValue);
+    issues = listIssues(config.issueDiscoveryTechnique, config.issueDiscoveryValue, limit);
   } catch (err) {
     process.stderr.write(`Error: ${err.message}
 `);
     process.exit(1);
   }
-  if (issue === null) {
-    process.stdout.write("No issues found matching the configured filter.\n");
-    process.exit(0);
-  }
+  const issue = await resolveIssue(issues, options, limit);
   if (options.json) {
     process.stdout.write(JSON.stringify({ number: issue.number, title: issue.title, body: issue.body, url: issue.url }, null, 2) + "\n");
   } else {
-    process.stdout.write(`Issue:  #${issue.number}
-Title:  ${issue.title}
-URL:    ${issue.url}
+    process.stdout.write(`URL:    ${issue.url}
 
 ${issue.body}
 `);
@@ -1372,7 +1917,9 @@ ${issue.body}
   }
   if (options.claude !== false) {
     const systemPrompt = config.claudeSystemPrompt ?? DEFAULT_CLAUDE_SYSTEM_PROMPT;
-    const prompt = `${systemPrompt}
+    const prompt = `Resolving issue #${issue.number}:
+
+${systemPrompt}
 
 ${issue.body}`;
     if (options.codex) {
@@ -1384,16 +1931,62 @@ ${issue.body}`;
   }
 });
 
-// src/commands/test.ts
+// src/commands/execute.ts
+import { readFileSync as readFileSync3 } from "fs";
 import { Command as Command4 } from "commander";
-var testClaudeCmd = new Command4("claude").description("Test Claude Code invocation with a user-supplied prompt").requiredOption("--prompt <string>", "Prompt to send to Claude Code").option("--yolo", "Launch Claude Code with --dangerously-skip-permissions").option("--verbose", "Show step-by-step progress summary and final result").option("--opus", "Use claude-opus-4-6").option("--sonnet", "Use claude-sonnet-4-6").option("--haiku", "Use claude-haiku-4-5-20251001").action(async (options) => {
-  const model = resolveModelOption(options);
-  await invokeClaudeCode(options.prompt, { yolo: options.yolo, verbose: options.verbose, model });
-});
-var testCodexCmd = new Command4("codex").description("Test Codex CLI invocation with a user-supplied prompt").requiredOption("--prompt <string>", "Prompt to send to Codex CLI").option("--yolo", "Launch Codex with --dangerously-bypass-approvals-and-sandbox").option("--verbose", "Not supported for Codex; prints a warning and is otherwise ignored").action((options) => {
-  invokeCodexCode(options.prompt, { yolo: options.yolo, verbose: options.verbose });
+function readStdin() {
+  return new Promise((resolve3, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
+    process.stdin.on("error", reject);
+  });
+}
+async function resolvePrompt(options) {
+  const hasCli = options.prompt !== void 0;
+  const hasFile = options.filePrompt !== void 0;
+  if (hasCli && hasFile) {
+    process.stderr.write("Error: --prompt is mutually exclusive with --file-prompt.\n");
+    process.exit(1);
+  }
+  if (hasCli) {
+    return options.prompt;
+  }
+  if (hasFile) {
+    const path = options.filePrompt;
+    try {
+      return readFileSync3(path, "utf8");
+    } catch {
+      process.stderr.write(`Error: Cannot read file: ${path}
+`);
+      process.exit(1);
+    }
+  }
+  if (!process.stdin.isTTY) {
+    const content = await readStdin();
+    if (content.trim().length === 0) {
+      process.stderr.write("Error: No prompt provided. Use --prompt, --file-prompt, or pipe via stdin.\n");
+      process.exit(1);
+    }
+    return content;
+  }
+  process.stderr.write("Error: No prompt provided. Use --prompt, --file-prompt, or pipe via stdin.\n");
+  process.exit(1);
+}
+var executeCommand = new Command4("execute").description("Delegate work to an AI executor").requiredOption("--with <executor>", "Executor to use: claude or codex").option("--prompt <string>", "Prompt to send to the executor").option("--file-prompt <path>", "Path to a file whose content is used as the prompt").option("--silent", "Suppress step-by-step Claude output; show only the final summary").option("--model <string>", "Model identifier to pass to the executor").action(async (options) => {
+  const executor = options.with.toLowerCase();
+  if (executor !== "claude" && executor !== "codex") {
+    process.stderr.write(`Error: --with must be 'claude' or 'codex', got '${options.with}'.
+`);
+    process.exit(1);
+  }
+  const prompt = await resolvePrompt(options);
+  if (executor === "codex") {
+    invokeCodexCode(prompt, { yolo: true, model: options.model });
+  } else {
+    await invokeClaudeCode(prompt, { yolo: true, verbose: !options.silent, model: options.model });
+  }
 });
-var testCommand = new Command4("test").description("Test commands for verifying automata integrations").addCommand(testClaudeCmd).addCommand(testCodexCmd);
 
 // src/commands/executePrompt.ts
 import { Command as Command5 } from "commander";
@@ -1403,6 +1996,9 @@ function withPush(prompt, push) {
 
 ${PUSH_INSTRUCTION}` : prompt;
 }
+function formatPrInfoContext(pr) {
+  return JSON.stringify(pr, null, 2);
+}
 function addAiOptions(cmd) {
   return cmd.option("--codex", "Use Codex CLI instead of Claude Code").option("--verbose", "Show step-by-step progress (Claude only; ignored for Codex)").option("--push", "Append instruction to commit and push changes after the AI finishes").option("--opus", "Use claude-opus-4-6 (Claude only)").option("--sonnet", "Use claude-sonnet-4-6 (Claude only)").option("--haiku", "Use claude-haiku-4-5-20251001 (Claude only)");
 }
@@ -1444,7 +2040,10 @@ var executeSonarCmd = addAiOptions(
   const fullPrompt = withPush(
     `${sonarPromptText}
 
-SonarCloud analysis URL: ${pr.sonarcloudUrl}`,
+SonarCloud analysis URL: ${pr.sonarcloudUrl}
+
+Current PR context from automata git get-pr-info --json:
+${formatPrInfoContext(pr)}`,
     options.push
   );
   if (options.codex) {
@@ -1517,7 +2116,7 @@ program.name("automata").description("Automata CLI tool").version(version, "-v,
 program.addCommand(configCommand);
 program.addCommand(gitCommand);
 program.addCommand(implementNextCommand);
-program.addCommand(testCommand);
+program.addCommand(executeCommand);
 program.addCommand(executePromptCommand);
 program.showHelpAfterError();
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.1.0-bugfix-automata-deletion.94",
+  "version": "0.1.0-feature-021-execute-command.127",
   "description": "Automata CLI tool",
   "type": "module",
   "bin": {