@nyxa/nyx-agent 0.8.1 → 0.9.0

package/README.md

@@ -7,9 +7,9 @@ GitHub issue at a time, each phase with fresh context.
 
 For every run NyxAgent:
 
-1. **Selects** executable open GitHub issues to work on (read-only), grouping
-   GitHub sub-issues under non-executable parent PRD/plan issues, then asks the
-   user to confirm the proposed checklist.
+1. **Selects** executable open GitHub issues to work on (read-only), presenting
+   GitHub sub-issues in parent PRD/plan sections, then asks the user to confirm
+   the proposed checklist with the same section order.
 2. For each selected issue, in an isolated git **worktree**:
    - **implements** it (the agent — the only customizable prompt),
    - optionally **reviews** it in bounded discovery rounds, then revises only

package/dist/runtime/runPipeline.js

@@ -11,7 +11,7 @@ import { createRunReporter } from "./reporter.js";
 import { runAgentPhase, } from "./runPhase.js";
 import { REVIEW_CHALLENGE_SCHEMA, REVIEW_DISCOVERY_SCHEMA, GLOBAL_REVIEW_SCHEMA, REVIEW_VALIDATION_SCHEMA, SELECTION_SCHEMA, } from "./schemas.js";
 import { commitAll, commitsAhead, createPullRequest, pushBranch, rangeDiff, stageAllAndDiff, } from "./scm.js";
-import { confirmWorkItemSelection, } from "./selectionConfirmation.js";
+import { buildSelectionSections, confirmWorkItemSelection, } from "./selectionConfirmation.js";
 import { createRunId } from "./time.js";
 import { filterAvailable, listGitHubWorkItemInventory, resolveSelectedQueue, } from "./workItems.js";
 const MAX_CANDIDATES = 50;
@@ -285,13 +285,9 @@ async function runSelection(input) {
         ["Max work items this run", input.config.max_iterations],
         [
             "Available candidates",
-            input.candidates.map((candidate) => ({
-                key: candidate.key,
-                number: candidate.number,
-                title: candidate.title,
-                labels: candidate.labels,
-                parent: candidate.parent,
-                excerpt: candidate.excerpt,
+            buildSelectionSections(input.candidates).map((section) => ({
+                section: section.label ?? "Ungrouped issues",
+                candidates: section.candidates.map(selectionCandidateSummary),
             })),
         ],
     ]);
@@ -880,6 +876,16 @@ function workItemSummary(item) {
         parent: item.parent,
     };
 }
+function selectionCandidateSummary(candidate) {
+    return {
+        key: candidate.key,
+        number: candidate.number,
+        title: candidate.title,
+        labels: candidate.labels,
+        parent: candidate.parent,
+        excerpt: candidate.excerpt,
+    };
+}
 function buildCommitMessage(item) {
     return `${item.title}\n\nWork item: ${item.source.locator}`;
 }

package/dist/runtime/selectionConfirmation.js

@@ -7,10 +7,11 @@ export async function confirmWorkItemSelection(input) {
     if (!isInteractive) {
         throw new Error('Interactive work item selection requires a TTY. Re-run with "nyxagent run --yes" to accept the agent selection.');
     }
+    const choiceItems = buildSelectionChoiceItems(input);
     const selectedKeys = await checkbox({
         message: `Select work items to run (max ${input.maxItems})`,
-        choices: buildSelectionChoiceItems(input).map(toInquirerChoice),
-        pageSize: Math.min(Math.max(input.candidates.length, 7), 20),
+        choices: choiceItems.map(toInquirerChoice),
+        pageSize: Math.min(Math.max(choiceItems.length, 7), 20),
         required: false,
         validate: (selected) => selected.length <= input.maxItems ||
             `Select at most ${input.maxItems} work item(s).`,
@@ -20,28 +21,58 @@ export async function confirmWorkItemSelection(input) {
         },
     });
     const selected = new Set(selectedKeys);
-    return input.candidates.filter((candidate) => selected.has(candidate.key));
+    const candidatesByKey = new Map(input.candidates.map((candidate) => [candidate.key, candidate]));
+    return choiceItems.flatMap((item) => {
+        if (item.type !== "choice" || !selected.has(item.value)) {
+            return [];
+        }
+        const candidate = candidatesByKey.get(item.value);
+        return candidate ? [candidate] : [];
+    });
 }
 export function buildSelectionChoiceItems(input) {
     const proposedKeys = new Set(input.proposed.map((item) => item.key));
     const items = [];
-    let currentGroup;
-    for (const candidate of input.candidates) {
-        const group = detectPlanGroup(candidate);
-        if (group && group !== currentGroup) {
-            items.push({ type: "separator", label: group });
+    for (const section of buildSelectionSections(input.candidates)) {
+        if (section.label) {
+            items.push({ type: "separator", label: section.label });
+        }
+        for (const candidate of section.candidates) {
+            const proposed = proposedKeys.has(candidate.key);
+            items.push({
+                type: "choice",
+                value: candidate.key,
+                name: `#${candidate.number} ${candidate.title}${proposed ? " (agent)" : ""}`,
+                checked: proposed,
+            });
         }
-        currentGroup = group;
-        const proposed = proposedKeys.has(candidate.key);
-        items.push({
-            type: "choice",
-            value: candidate.key,
-            name: `#${candidate.number} ${candidate.title}${proposed ? " (agent)" : ""}`,
-            checked: proposed,
-        });
     }
     return items;
 }
+export function buildSelectionSections(candidates) {
+    const sections = [];
+    const groupedSections = new Map();
+    let ungroupedSection;
+    for (const candidate of candidates) {
+        const group = detectSelectionGroup(candidate);
+        if (!group) {
+            if (!ungroupedSection) {
+                ungroupedSection = { candidates: [] };
+                sections.push(ungroupedSection);
+            }
+            ungroupedSection.candidates.push(candidate);
+            continue;
+        }
+        let section = groupedSections.get(group.key);
+        if (!section) {
+            section = { label: group.label, candidates: [] };
+            groupedSections.set(group.key, section);
+            sections.push(section);
+        }
+        section.candidates.push(candidate);
+    }
+    return sections;
+}
 function toInquirerChoice(item) {
     if (item.type === "separator") {
         return new Separator(item.label);
@@ -52,17 +83,23 @@ function toInquirerChoice(item) {
         checked: item.checked,
     };
 }
-function detectPlanGroup(candidate) {
+function detectSelectionGroup(candidate) {
     if (candidate.parent) {
-        return formatParentGroup(candidate.parent);
+        return {
+            key: `parent:${candidate.parent.key}`,
+            label: formatParentGroup(candidate.parent),
+        };
     }
     for (const label of candidate.labels ?? []) {
         const group = parseGroupLabel(label);
         if (group) {
-            return group;
+            return { key: `display:${group.toLowerCase()}`, label: group };
         }
     }
-    return parseBracketedTitleGroup(candidate.title);
+    const titleGroup = parseBracketedTitleGroup(candidate.title);
+    return titleGroup
+        ? { key: `display:${titleGroup.toLowerCase()}`, label: titleGroup }
+        : undefined;
 }
 function formatParentGroup(parent) {
     if (!parent) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nyxa/nyx-agent",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "A lightweight phase orchestrator for repeatedly launching coding agents with fresh context.",
   "type": "module",
   "repository": {