@nyxa/nyx-agent 0.4.1 → 0.6.0

package/dist/runtime/workItems.js

@@ -1,79 +1,11 @@
-import { readdir, readFile, stat } from "node:fs/promises";
-import path from "node:path";
+/** Work items: lists GitHub issues via `gh`, normalizes them to candidates, and resolves the selected queue. */
 import { execa } from "execa";
-export async function listWorkItemCandidates(input) {
-    const workItems = input.config.work_items;
-    if (!workItems) {
-        return [];
-    }
-    if (workItems.source === "local") {
-        if (!workItems.path) {
-            throw new Error('Local work items require [work_items].path');
-        }
-        return listLocalWorkItemCandidates({
-            projectRoot: input.projectRoot,
-            workItemsPath: workItems.path,
-            maxCandidates: workItems.max_candidates,
-            excerptChars: workItems.excerpt_chars
-        });
-    }
-    if (!workItems.repository) {
-        throw new Error('GitHub work items require [work_items].repository');
-    }
-    return listGitHubWorkItemCandidates({
-        repository: workItems.repository,
-        maxCandidates: workItems.max_candidates,
-        excerptChars: workItems.excerpt_chars
-    });
-}
-export function filterAvailableWorkItems(input) {
-    const seen = new Set(input.seenWorkItemKeys);
-    const completed = new Set(input.completedWorkItemKeys);
-    return input.candidates.filter((candidate) => !seen.has(candidate.key) && !completed.has(candidate.key));
-}
-export async function listLocalWorkItemCandidates(input) {
-    const normalizedPath = normalizeProjectRelativePath(input.workItemsPath);
-    if (!normalizedPath) {
-        throw new Error("[work_items].path must be a canonical relative path");
-    }
-    const root = path.resolve(input.projectRoot);
-    const workItemsDir = path.resolve(root, normalizedPath);
-    const relative = path.relative(root, workItemsDir);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
-        throw new Error("[work_items].path must stay inside the project root");
-    }
-    const dirStat = await stat(workItemsDir).catch((error) => {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Local work item path does not exist: ${normalizedPath} (${message})`);
-    });
-    if (!dirStat.isDirectory()) {
-        throw new Error(`Local work item path is not a directory: ${normalizedPath}`);
-    }
-    const files = (await collectMarkdownFiles(workItemsDir))
-        .map((filePath) => toPosixPath(path.relative(root, filePath)))
-        .sort((left, right) => left.localeCompare(right));
-    const candidates = [];
-    for (const locator of files.slice(0, input.maxCandidates)) {
-        const absolutePath = path.join(root, locator);
-        const content = await readFile(absolutePath, "utf8");
-        candidates.push({
-            key: `local:${locator}`,
-            title: inferMarkdownTitle(content, locator),
-            source: {
-                type: "local",
-                locator
-            },
-            excerpt: buildExcerpt(content, input.excerptChars)
-        });
-    }
-    return candidates;
-}
-export async function listGitHubWorkItemCandidates(input) {
+export async function listGitHubIssues(input) {
     const result = await execa("gh", [
         "issue",
         "list",
         "--repo",
-        input.repository,
+        input.repo,
         "--state",
         "open",
         "--limit",
@@ -83,7 +15,7 @@ export async function listGitHubWorkItemCandidates(input) {
     ], { reject: false });
     if (result.exitCode !== 0) {
         const detail = (result.stderr || result.stdout || "unknown error").trim();
-        throw new Error(`Failed to list GitHub work items with gh: ${detail}`);
+        throw new Error(`Failed to list GitHub issues with gh: ${detail}`);
     }
     let issues;
     try {
@@ -96,13 +28,46 @@ export async function listGitHubWorkItemCandidates(input) {
     if (!Array.isArray(issues)) {
         throw new Error("gh issue list returned JSON that is not an array");
     }
-    return issues.slice(0, input.maxCandidates).map((issue) => normalizeGitHubIssue({
+    return issues
+        .slice(0, input.maxCandidates)
+        .map((issue) => normalizeIssue({
         issue,
-        repository: input.repository,
+        repo: input.repo,
         excerptChars: input.excerptChars
     }));
 }
-function normalizeGitHubIssue(input) {
+export function filterAvailable(input) {
+    const completed = new Set(input.completedKeys);
+    return input.candidates.filter((candidate) => !completed.has(candidate.key));
+}
+/** Resolve the selection phase's ordered keys against the available candidates. */
+export function resolveSelectedQueue(input) {
+    if (!Array.isArray(input.keys)) {
+        return { ok: false, error: "selection work_item_keys must be an array" };
+    }
+    const byKey = new Map(input.candidates.map((c) => [c.key, c]));
+    const seen = new Set();
+    const queue = [];
+    for (const key of input.keys) {
+        if (typeof key !== "string") {
+            return { ok: false, error: "selection work_item_keys must be strings" };
+        }
+        if (seen.has(key)) {
+            return { ok: false, error: `selection contains duplicate key "${key}"` };
+        }
+        const candidate = byKey.get(key);
+        if (!candidate) {
+            return {
+                ok: false,
+                error: `selection key "${key}" is not an available candidate`
+            };
+        }
+        seen.add(key);
+        queue.push(candidate);
+    }
+    return { ok: true, queue };
+}
+function normalizeIssue(input) {
     if (!isRecord(input.issue)) {
         throw new Error("gh issue list returned a non-object issue");
     }
@@ -114,14 +79,12 @@ function normalizeGitHubIssue(input) {
     if (typeof title !== "string" || title.length === 0) {
         throw new Error(`GitHub issue #${number} is missing a title`);
     }
-    const locator = `${input.repository}#${number}`;
+    const locator = `${input.repo}#${number}`;
     const candidate = {
         key: `github:${locator}`,
         title,
-        source: {
-            type: "github",
-            locator
-        },
+        number,
+        source: { type: "github", locator },
         labels: normalizeLabels(input.issue.labels)
     };
     if (typeof input.issue.url === "string" && input.issue.url.length > 0) {
@@ -136,28 +99,6 @@ function normalizeGitHubIssue(input) {
     }
     return candidate;
 }
-async function collectMarkdownFiles(dir) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    const files = [];
-    for (const entry of entries) {
-        const filePath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            files.push(...(await collectMarkdownFiles(filePath)));
-            continue;
-        }
-        if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
-            files.push(filePath);
-        }
-    }
-    return files;
-}
-function inferMarkdownTitle(content, locator) {
-    const heading = /^\s{0,3}#{1,6}\s+(.+?)\s*#*\s*$/m.exec(content);
-    if (heading?.[1]) {
-        return heading[1].trim();
-    }
-    return path.posix.basename(locator, ".md");
-}
 function buildExcerpt(content, maxChars) {
     if (maxChars <= 0) {
         return undefined;
@@ -191,22 +132,6 @@ function normalizeLabels(labels) {
         .filter((label) => Boolean(label));
     return normalized.length > 0 ? normalized : undefined;
 }
-function normalizeProjectRelativePath(value) {
-    if (value.length === 0 ||
-        value.includes("\\") ||
-        path.posix.isAbsolute(value) ||
-        /^[A-Za-z]:[\\/]/.test(value)) {
-        return undefined;
-    }
-    const normalized = path.posix.normalize(value);
-    if (normalized === "." || normalized === ".." || normalized.startsWith("../")) {
-        return undefined;
-    }
-    return normalized;
-}
-function toPosixPath(value) {
-    return value.split(path.sep).join(path.posix.sep);
-}
 function isRecord(value) {
     return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nyxa/nyx-agent",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "A lightweight phase orchestrator for repeatedly launching coding agents with fresh context.",
   "type": "module",
   "repository": {
@@ -11,9 +11,7 @@
     "nyxagent": "dist/cli.js"
   },
   "files": [
-    "dist",
-    "templates",
-    "docs"
+    "dist"
   ],
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
@@ -34,7 +32,6 @@
     "commander": "^14.0.0",
     "execa": "^9.6.0",
     "picocolors": "^1.1.0",
-    "smol-toml": "^1.3.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {

package/dist/runtime/buildPrompt.js

@@ -1,54 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { resolveNyxPath } from "./paths.js";
-import { renderTemplate } from "./renderTemplate.js";
-export async function buildPhasePrompt(input) {
-    const promptPath = resolveNyxPath(input.projectRoot, input.phase.prompt, `prompt for phase "${input.phase.id}"`);
-    const promptTemplate = await readFile(promptPath, "utf8");
-    const userPrompt = renderTemplate(promptTemplate, input.context);
-    const runtimeContract = await buildRuntimeContract(input);
-    return `${runtimeContract}\n\n# Phase Prompt\n\n${userPrompt}`;
-}
-async function buildRuntimeContract(input) {
-    const requiresResult = phaseRequiresStructuredResult(input.phase);
-    const schemaText = input.phase.output_schema
-        ? await readFile(resolveNyxPath(input.projectRoot, input.phase.output_schema, `output_schema for phase "${input.phase.id}"`), "utf8")
-        : undefined;
-    const workdir = typeof input.context.workdir === "string"
-        ? input.context.workdir
-        : input.projectRoot;
-    const git = input.context.git;
-    const lines = [
-        "# NyxAgent Runtime Contract",
-        "",
-        "You are running as one isolated phase in a NyxAgent workflow.",
-        "Follow the phase prompt, but obey this runtime contract first.",
-        "",
-        `Project root: ${input.projectRoot}`,
-        `Working directory: ${workdir}`
-    ];
-    if (workdir !== input.projectRoot) {
-        lines.push("Run all commands and edit files from the working directory above (an", "isolated git worktree). The project root only holds NyxAgent run artifacts.");
-    }
-    if (git?.branch) {
-        lines.push(`Git branch: ${git.branch} (base ${git.base ?? "unknown"})`);
-    }
-    lines.push(`Run dir: ${input.runDir}`, `Iteration dir: ${input.iterationDir}`, `Phase dir: ${input.phaseDir}`, `State file: ${input.stateFile}`, `Phase id: ${input.phase.id}`, "", "Current state:", "```json", JSON.stringify(input.context.state ?? {}, null, 2), "```", "", "Work item configuration:", "```json", JSON.stringify(input.config.work_items ?? {}, null, 2), "```", "", "Available work items:", "```json", JSON.stringify(input.context.available_work_items ?? [], null, 2), "```", "", "Recommended work item queue:", "```json", JSON.stringify(input.context.recommended_work_item_queue ?? [], null, 2), "```", "", "Selected work item queue:", "```json", JSON.stringify(input.context.selected_work_item_queue ?? [], null, 2), "```", "", "Work item annotations:", "```json", JSON.stringify(input.context.work_item_annotations ?? [], null, 2), "```", "", "Seen work item keys:", "```json", JSON.stringify(input.context.seen_work_item_keys ?? [], null, 2), "```", "", "Completed work item keys:", "```json", JSON.stringify(input.context.completed_work_item_keys ?? [], null, 2), "```", "", "Last completed work item:", "```json", JSON.stringify(input.context.last_completed_work_item ?? null, null, 2), "```");
-    if (input.phase.transitions) {
-        lines.push("", "Configured outcome transitions:", "```json", JSON.stringify(input.phase.transitions, null, 2), "```");
-    }
-    if (requiresResult) {
-        lines.push("", "Structured result is required.", "Return the structured result in stdout inside the final <nyxagent_result> XML block.", "NyxAgent will parse the last <nyxagent_result> block, validate it, and write result.json.", "Do not write result.json yourself.", "", "Result format:", "```xml", "<nyxagent_result>", "{", '  "outcome": "one_of_the_configured_outcomes"', "}", "</nyxagent_result>", "```");
-        if (input.phase.transitions) {
-            lines.push("", `The JSON object must include an "outcome" matching one of: ${Object.keys(input.phase.transitions).join(", ")}.`);
-        }
-    }
-    if (schemaText) {
-        lines.push("", "Expected JSON Schema:", "```json", schemaText.trim(), "```");
-    }
-    return lines.join("\n");
-}
-export function phaseRequiresStructuredResult(phase) {
-    return Boolean(phase.required_output ||
-        phase.output_schema ||
-        (phase.transitions && Object.keys(phase.transitions).length > 0));
-}

package/dist/runtime/effectiveConfig.js

@@ -1,14 +0,0 @@
-export function getEffectiveModel(config, phase) {
-    return {
-        ...config.model,
-        ...(phase.model ?? {})
-    };
-}
-export function getEffectiveHarness(config, phase) {
-    return {
-        ...config.harness,
-        ...(phase.harness ?? {}),
-        args: phase.harness?.args ?? config.harness.args,
-        prompt_input: phase.harness?.prompt_input ?? config.harness.prompt_input
-    };
-}

package/dist/runtime/renderTemplate.js

@@ -1,28 +0,0 @@
-const templatePattern = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
-export function renderTemplate(input, context) {
-    return input.replace(templatePattern, (_match, key) => {
-        const value = readPath(context, key);
-        if (value === undefined || value === null) {
-            return "";
-        }
-        if (typeof value === "string") {
-            return value;
-        }
-        if (typeof value === "number" ||
-            typeof value === "boolean" ||
-            typeof value === "bigint") {
-            return String(value);
-        }
-        return JSON.stringify(value, null, 2);
-    });
-}
-export function readPath(context, key) {
-    return key.split(".").reduce((current, segment) => {
-        if (current &&
-            typeof current === "object" &&
-            Object.prototype.hasOwnProperty.call(current, segment)) {
-            return current[segment];
-        }
-        return undefined;
-    }, context);
-}