@xn-intenton-z2a/agentic-lib 7.4.8 → 7.4.9

package/src/actions/agentic-step/tasks/enhance-issue.js

@@ -2,18 +2,35 @@
 // Copyright (C) 2025-2026 Polycode Limited
 // tasks/enhance-issue.js — Add testable acceptance criteria to issues
 //
-// Takes an issue and enhances it with clear, testable acceptance criteria
-// so that the resolve-issue task can implement it effectively.
-// Supports batch mode: when no issueNumber is provided, enhances up to 3 issues.
+// Uses runCopilotSession with lean prompts: the model reads features and docs
+// via tools to enhance issues with acceptance criteria.
 
 import * as core from "@actions/core";
+import { existsSync, readdirSync } from "fs";
 import { isIssueResolved } from "../safety.js";
-import { runCopilotTask, readOptionalFile, scanDirectory } from "../copilot.js";
+import { readOptionalFile, extractNarrative, NARRATIVE_INSTRUCTION } from "../copilot.js";
+import { runCopilotSession } from "../../../copilot/copilot-session.js";
+import { createGitHubTools } from "../../../copilot/github-tools.js";
+
+/**
+ * Build a file listing summary (names only).
+ */
+function listFiles(dirPath, extension) {
+  if (!dirPath || !existsSync(dirPath)) return [];
+  try {
+    return readdirSync(dirPath, { recursive: true })
+      .filter((f) => String(f).endsWith(extension))
+      .map((f) => String(f))
+      .slice(0, 20);
+  } catch {
+    return [];
+  }
+}
 
 /**
  * Enhance a single GitHub issue with testable acceptance criteria.
  */
-async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instructions, model, tuning: t }) {
+async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instructions, model, tuning: t, logFilePath, screenshotFilePath }) {
   if (await isIssueResolved(octokit, repo, issueNumber)) {
     return { outcome: "nop", details: `Issue #${issueNumber} already resolved` };
   }
@@ -28,10 +45,13 @@ async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instruct
   }
 
   const contributing = readOptionalFile(config.paths.contributing.path);
-  const features = scanDirectory(config.paths.features.path, ".md", { contentLimit: t.documentSummary || 2000 });
+  const featureFiles = listFiles(config.paths.features.path, ".md");
 
   const agentInstructions = instructions || "Enhance this issue with clear, testable acceptance criteria.";
 
+  // Shared mutable state to capture the enhanced body
+  const enhanceResult = { body: "" };
+
   const prompt = [
     "## Instructions",
     agentInstructions,
@@ -39,39 +59,71 @@ async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instruct
     `## Issue #${issueNumber}: ${issue.title}`,
     issue.body || "(no description)",
     "",
-    contributing ? `## Contributing Guidelines\n${contributing.substring(0, t.documentSummary || 2000)}` : "",
-    features.length > 0 ? `## Related Features\n${features.map((f) => f.content).join("\n---\n")}` : "",
-    config.configToml ? `## Configuration (agentic-lib.toml)\n\`\`\`toml\n${config.configToml}\n\`\`\`` : "",
-    config.packageJson ? `## Dependencies (package.json)\n\`\`\`json\n${config.packageJson}\n\`\`\`` : "",
+    contributing ? `## Contributing Guidelines\n${contributing.substring(0, 2000)}` : "",
+    featureFiles.length > 0 ? `## Feature Files (read with read_file for details)\n${featureFiles.join(", ")}` : "",
     "",
     "## Your Task",
+    "Read relevant feature files if needed using read_file.",
     "Write an enhanced version of this issue body that includes:",
     "1. Clear problem statement or feature description",
     "2. Testable acceptance criteria (Given/When/Then or checkbox format)",
     "3. Implementation hints if applicable",
     "",
-    "Output ONLY the new issue body text, no markdown code fences.",
+    "**Call report_enhanced_body exactly once** with the improved issue body.",
   ].join("\n");
 
-  const {
-    content: enhancedBody,
-    tokensUsed,
-    inputTokens,
-    outputTokens,
-    cost,
-  } = await runCopilotTask({
+  const systemPrompt =
+    "You are a requirements analyst. Enhance GitHub issues with clear, testable acceptance criteria." +
+    NARRATIVE_INSTRUCTION;
+
+  const createTools = (defineTool, _wp, logger) => {
+    const ghTools = createGitHubTools(octokit, repo, defineTool, logger);
+
+    const reportEnhancedBody = defineTool("report_enhanced_body", {
+      description: "Report the enhanced issue body with testable acceptance criteria. Call this exactly once.",
+      parameters: {
+        type: "object",
+        properties: {
+          enhanced_body: { type: "string", description: "The complete enhanced issue body text" },
+        },
+        required: ["enhanced_body"],
+      },
+      handler: async ({ enhanced_body }) => {
+        enhanceResult.body = enhanced_body;
+        return { textResultForLlm: "Enhanced body recorded." };
+      },
+    });
+
+    return [...ghTools, reportEnhancedBody];
+  };
+
+  const attachments = [];
+  if (logFilePath) attachments.push({ type: "file", path: logFilePath });
+  if (screenshotFilePath) attachments.push({ type: "file", path: screenshotFilePath });
+
+  const result = await runCopilotSession({
+    workspacePath: process.cwd(),
     model,
-    systemMessage: "You are a requirements analyst. Enhance GitHub issues with clear, testable acceptance criteria.",
-    prompt,
-    writablePaths: [],
     tuning: t,
+    agentPrompt: systemPrompt,
+    userPrompt: prompt,
+    writablePaths: [],
+    createTools,
+    attachments,
+    excludedTools: ["write_file", "run_command", "run_tests", "dispatch_workflow", "close_issue", "label_issue", "post_discussion_comment"],
+    logger: { info: core.info, warning: core.warning, error: core.error, debug: core.debug },
   });
 
-  if (enhancedBody.trim()) {
+  const tokensUsed = result.tokensIn + result.tokensOut;
+
+  // Fall back to agent message if report_enhanced_body wasn't called
+  const enhancedBody = enhanceResult.body || (result.agentMessage || "").trim();
+
+  if (enhancedBody) {
     await octokit.rest.issues.update({
       ...repo,
       issue_number: Number(issueNumber),
-      body: enhancedBody.trim(),
+      body: enhancedBody,
     });
     await octokit.rest.issues.addLabels({
       ...repo,
@@ -86,7 +138,6 @@ async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instruct
         "",
         `**Task:** enhance-issue`,
         `**Model:** ${model}`,
-        `**Features referenced:** ${features.length}`,
         "",
         "The issue body has been updated. The `ready` label has been added to indicate it is ready for implementation.",
       ].join("\n"),
@@ -97,12 +148,12 @@ async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instruct
   return {
     outcome: "issue-enhanced",
     tokensUsed,
-    inputTokens,
-    outputTokens,
-    cost,
+    inputTokens: result.tokensIn,
+    outputTokens: result.tokensOut,
+    cost: 0,
     model,
     details: `Enhanced issue #${issueNumber} with acceptance criteria`,
-    narrative: `Enhanced issue #${issueNumber} with testable acceptance criteria.`,
+    narrative: result.narrative || `Enhanced issue #${issueNumber} with testable acceptance criteria.`,
   };
 }
 
@@ -114,12 +165,12 @@ async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instruct
  * @returns {Promise<Object>} Result with outcome, tokensUsed, model
  */
 export async function enhanceIssue(context) {
-  const { octokit, repo, config, issueNumber, instructions, model } = context;
+  const { octokit, repo, config, issueNumber, instructions, model, logFilePath, screenshotFilePath } = context;
   const t = config.tuning || {};
 
   // Single issue mode
   if (issueNumber) {
-    return enhanceSingleIssue({ octokit, repo, config, issueNumber, instructions, model, tuning: t });
+    return enhanceSingleIssue({ octokit, repo, config, issueNumber, instructions, model, tuning: t, logFilePath, screenshotFilePath });
   }
 
   // Batch mode: find up to 3 unready automated issues
@@ -141,7 +192,6 @@ export async function enhanceIssue(context) {
   let totalTokens = 0;
   let totalInputTokens = 0;
   let totalOutputTokens = 0;
-  let totalCost = 0;
 
   for (const issue of unready) {
     core.info(`Batch enhancing issue #${issue.number} (${results.length + 1}/${unready.length})`);
@@ -153,12 +203,13 @@ export async function enhanceIssue(context) {
       instructions,
       model,
       tuning: t,
+      logFilePath,
+      screenshotFilePath,
     });
     results.push(result);
     totalTokens += result.tokensUsed || 0;
     totalInputTokens += result.inputTokens || 0;
     totalOutputTokens += result.outputTokens || 0;
-    totalCost += result.cost || 0;
   }
 
   const enhanced = results.filter((r) => r.outcome === "issue-enhanced").length;
@@ -168,7 +219,7 @@ export async function enhanceIssue(context) {
     tokensUsed: totalTokens,
     inputTokens: totalInputTokens,
     outputTokens: totalOutputTokens,
-    cost: totalCost,
+    cost: 0,
     model,
     details: `Batch enhanced ${enhanced}/${results.length} issues. ${results
       .map((r) => r.details)

package/src/actions/agentic-step/tasks/fix-code.js

@@ -2,14 +2,15 @@
 // Copyright (C) 2025-2026 Polycode Limited
 // tasks/fix-code.js — Fix failing tests or resolve merge conflicts on a PR
 //
-// Given a PR number, detects merge conflicts or failing checks and resolves them.
-// Conflict resolution: reads files with conflict markers, asks the LLM to resolve.
-// Failing checks: analyzes test output, generates code fixes.
+// Uses runCopilotSession with lean prompts: the model reads files, analyzes
+// failures, writes fixes, and runs tests via tools.
 
 import * as core from "@actions/core";
 import { readFileSync } from "fs";
 import { execSync } from "child_process";
-import { runCopilotTask, formatPathsSection, extractNarrative, NARRATIVE_INSTRUCTION } from "../copilot.js";
+import { formatPathsSection, extractNarrative, NARRATIVE_INSTRUCTION } from "../copilot.js";
+import { runCopilotSession } from "../../../copilot/copilot-session.js";
+import { createGitHubTools, createGitTools } from "../../../copilot/github-tools.js";
 
 /**
  * Extract run_id from a check run's details_url.
@@ -40,13 +41,8 @@ function fetchRunLog(runId) {
 
 /**
  * Resolve merge conflicts on a PR using the Copilot SDK.
- * Called when the workflow has started a `git merge origin/main` that left
- * conflict markers in non-trivial files (listed in NON_TRIVIAL_FILES env var).
- *
- * @param {Object} params
- * @returns {Promise<Object>} Result with outcome, tokensUsed, model
  */
-async function resolveConflicts({ config, pr, prNumber, instructions, model, writablePaths, testCommand }) {
+async function resolveConflicts({ config, pr, prNumber, instructions, model, writablePaths, testCommand, octokit, repo, logFilePath, screenshotFilePath }) {
   const nonTrivialEnv = process.env.NON_TRIVIAL_FILES || "";
   const conflictedPaths = nonTrivialEnv
     .split("\n")
@@ -70,7 +66,6 @@ async function resolveConflicts({ config, pr, prNumber, instructions, model, wri
   });
 
   const agentInstructions = instructions || "Resolve the merge conflicts while preserving the PR's intended changes.";
-  const readOnlyPaths = config.readOnlyPaths;
 
   const prompt = [
     "## Instructions",
@@ -89,42 +84,60 @@ async function resolveConflicts({ config, pr, prNumber, instructions, model, wri
     `## Conflicted Files (${conflicts.length})`,
     ...conflicts.map((f) => `### ${f.name}\n\`\`\`\n${f.content}\n\`\`\``),
     "",
-    formatPathsSection(writablePaths, readOnlyPaths, config),
+    formatPathsSection(writablePaths, config.readOnlyPaths, config),
     "",
     "## Constraints",
     "- Remove ALL conflict markers (<<<<<<, =======, >>>>>>>)",
     "- Preserve the PR's feature/fix intent",
-    `- Run \`${testCommand}\` to validate your resolution`,
+    `- Run \`${testCommand}\` via run_tests to validate your resolution`,
   ].join("\n");
 
   const t = config.tuning || {};
-  const { tokensUsed, inputTokens, outputTokens, cost, content: resultContent } = await runCopilotTask({
+  const systemPrompt =
+    `You are resolving git merge conflicts on PR #${prNumber}. Write resolved versions of each conflicted file, removing all conflict markers. Preserve the PR's feature intent while incorporating main's updates.` +
+    NARRATIVE_INSTRUCTION;
+
+  const createTools = (defineTool, _wp, logger) => {
+    const ghTools = createGitHubTools(octokit, repo, defineTool, logger);
+    const gitTools = createGitTools(defineTool, logger);
+    return [...ghTools, ...gitTools];
+  };
+
+  const attachments = [];
+  if (logFilePath) attachments.push({ type: "file", path: logFilePath });
+  if (screenshotFilePath) attachments.push({ type: "file", path: screenshotFilePath });
+
+  const result = await runCopilotSession({
+    workspacePath: process.cwd(),
     model,
-    systemMessage: `You are resolving git merge conflicts on PR #${prNumber}. Write resolved versions of each conflicted file, removing all conflict markers. Preserve the PR's feature intent while incorporating main's updates.` + NARRATIVE_INSTRUCTION,
-    prompt,
-    writablePaths,
     tuning: t,
+    agentPrompt: systemPrompt,
+    userPrompt: prompt,
+    writablePaths,
+    createTools,
+    attachments,
+    excludedTools: ["dispatch_workflow", "close_issue", "label_issue", "post_discussion_comment"],
+    logger: { info: core.info, warning: core.warning, error: core.error, debug: core.debug },
   });
 
-  core.info(`Conflict resolution completed (${tokensUsed} tokens)`);
+  core.info(`Conflict resolution completed (${result.tokensIn + result.tokensOut} tokens)`);
 
   return {
     outcome: "conflicts-resolved",
-    tokensUsed,
-    inputTokens,
-    outputTokens,
-    cost,
+    tokensUsed: result.tokensIn + result.tokensOut,
+    inputTokens: result.tokensIn,
+    outputTokens: result.tokensOut,
+    cost: 0,
     model,
     details: `Resolved ${conflicts.length} conflicted file(s) on PR #${prNumber}`,
-    narrative: extractNarrative(resultContent, `Resolved ${conflicts.length} merge conflict(s) on PR #${prNumber}.`),
+    narrative: result.narrative || extractNarrative(result.agentMessage, `Resolved ${conflicts.length} merge conflict(s) on PR #${prNumber}.`),
   };
 }
 
 /**
  * Fix a broken main branch build.
- * Called when no PR is involved — just a failing workflow run on main.
  */
-async function fixMainBuild({ config, runId, instructions, model, writablePaths, testCommand }) {
+async function fixMainBuild({ config, runId, instructions, model, writablePaths, testCommand, octokit, repo, logFilePath, screenshotFilePath }) {
   const logContent = fetchRunLog(runId);
   if (!logContent) {
     core.info(`Could not fetch log for run ${runId}. Returning nop.`);
@@ -132,7 +145,6 @@ async function fixMainBuild({ config, runId, instructions, model, writablePaths,
   }
 
   const agentInstructions = instructions || "Fix the failing tests by modifying the source code.";
-  const readOnlyPaths = config.readOnlyPaths;
 
   const prompt = [
     "## Instructions",
@@ -145,34 +157,57 @@ async function fixMainBuild({ config, runId, instructions, model, writablePaths,
     "## Failed Run Log",
     logContent,
     "",
-    formatPathsSection(writablePaths, readOnlyPaths, config),
+    "## Your Task",
+    "Use read_file to read the relevant source and test files.",
+    "Make minimal changes to fix the failing tests, then run run_tests to verify.",
+    "",
+    formatPathsSection(writablePaths, config.readOnlyPaths, config),
     "",
     "## Constraints",
-    `- Run \`${testCommand}\` to validate your fixes`,
+    `- Run \`${testCommand}\` via run_tests to validate your fixes`,
     "- Make minimal changes to fix the failing tests",
     "- Do not introduce new features — focus on making the build green",
   ].join("\n");
 
   const t = config.tuning || {};
-  const { tokensUsed, inputTokens, outputTokens, cost, content: resultContent } = await runCopilotTask({
+  const systemPrompt =
+    `You are an autonomous coding agent fixing a broken build on the main branch. The test/build workflow has failed. Analyze the error log and make minimal, targeted changes to fix it.` +
+    NARRATIVE_INSTRUCTION;
+
+  const createTools = (defineTool, _wp, logger) => {
+    const ghTools = createGitHubTools(octokit, repo, defineTool, logger);
+    const gitTools = createGitTools(defineTool, logger);
+    return [...ghTools, ...gitTools];
+  };
+
+  const attachments = [];
+  if (logFilePath) attachments.push({ type: "file", path: logFilePath });
+  if (screenshotFilePath) attachments.push({ type: "file", path: screenshotFilePath });
+
+  const result = await runCopilotSession({
+    workspacePath: process.cwd(),
     model,
-    systemMessage: `You are an autonomous coding agent fixing a broken build on the main branch. The test/build workflow has failed. Analyze the error log and make minimal, targeted changes to fix it.` + NARRATIVE_INSTRUCTION,
-    prompt,
-    writablePaths,
     tuning: t,
+    agentPrompt: systemPrompt,
+    userPrompt: prompt,
+    writablePaths,
+    createTools,
+    attachments,
+    excludedTools: ["dispatch_workflow", "close_issue", "label_issue", "post_discussion_comment"],
+    logger: { info: core.info, warning: core.warning, error: core.error, debug: core.debug },
   });
 
-  core.info(`Main build fix completed (${tokensUsed} tokens)`);
+  core.info(`Main build fix completed (${result.tokensIn + result.tokensOut} tokens)`);
 
   return {
     outcome: "fix-applied",
-    tokensUsed,
-    inputTokens,
-    outputTokens,
-    cost,
+    tokensUsed: result.tokensIn + result.tokensOut,
+    inputTokens: result.tokensIn,
+    outputTokens: result.tokensOut,
+    cost: 0,
     model,
     details: `Applied fix for broken main build (run ${runId})`,
-    narrative: extractNarrative(resultContent, `Fixed broken main build (run ${runId}).`),
+    narrative: result.narrative || extractNarrative(result.agentMessage, `Fixed broken main build (run ${runId}).`),
   };
 }
 
@@ -180,19 +215,16 @@ async function fixMainBuild({ config, runId, instructions, model, writablePaths,
  * Fix failing code or resolve merge conflicts on a pull request,
  * or fix a broken build on main.
  *
- * Priority: main build fix (if FIX_RUN_ID env is set),
- * then conflicts (if NON_TRIVIAL_FILES env is set), then failing checks.
- *
  * @param {Object} context - Task context from index.js
  * @returns {Promise<Object>} Result with outcome, tokensUsed, model
  */
 export async function fixCode(context) {
-  const { octokit, repo, config, prNumber, instructions, writablePaths, testCommand, model } = context;
+  const { octokit, repo, config, prNumber, instructions, writablePaths, testCommand, model, logFilePath, screenshotFilePath } = context;
 
   // Fix main build (no PR involved)
   const fixRunId = process.env.FIX_RUN_ID || "";
   if (fixRunId && !prNumber) {
-    return fixMainBuild({ config, runId: fixRunId, instructions, model, writablePaths, testCommand });
+    return fixMainBuild({ config, runId: fixRunId, instructions, model, writablePaths, testCommand, octokit, repo, logFilePath, screenshotFilePath });
   }
 
   if (!prNumber) {
@@ -204,7 +236,7 @@ export async function fixCode(context) {
 
   // If we have non-trivial conflict files from the workflow's Tier 1 step, resolve them
   if (process.env.NON_TRIVIAL_FILES) {
-    return resolveConflicts({ config, pr, prNumber, instructions, model, writablePaths, testCommand });
+    return resolveConflicts({ config, pr, prNumber, instructions, model, writablePaths, testCommand, octokit, repo, logFilePath, screenshotFilePath });
   }
 
   // Otherwise, check for failing checks
@@ -230,7 +262,6 @@ export async function fixCode(context) {
     .join("\n\n");
 
   const agentInstructions = instructions || "Fix the failing tests by modifying the source code.";
-  const readOnlyPaths = config.readOnlyPaths;
 
   const prompt = [
     "## Instructions",
@@ -243,32 +274,55 @@ export async function fixCode(context) {
     "## Failing Checks",
     failureDetails,
     "",
-    formatPathsSection(writablePaths, readOnlyPaths, config),
+    "## Your Task",
+    "Use read_file to read the relevant source and test files.",
+    "Make minimal changes to fix the failures, then run run_tests to verify.",
+    "",
+    formatPathsSection(writablePaths, config.readOnlyPaths, config),
     "",
     "## Constraints",
-    `- Run \`${testCommand}\` to validate your fixes`,
+    `- Run \`${testCommand}\` via run_tests to validate your fixes`,
     "- Make minimal changes to fix the failing tests",
   ].join("\n");
 
   const t = config.tuning || {};
-  const { tokensUsed, inputTokens, outputTokens, cost, content: resultContent } = await runCopilotTask({
+  const systemPrompt =
+    `You are an autonomous coding agent fixing failing tests on PR #${prNumber}. Make minimal, targeted changes to fix the test failures.` +
+    NARRATIVE_INSTRUCTION;
+
+  const createTools = (defineTool, _wp, logger) => {
+    const ghTools = createGitHubTools(octokit, repo, defineTool, logger);
+    const gitTools = createGitTools(defineTool, logger);
+    return [...ghTools, ...gitTools];
+  };
+
+  const attachments = [];
+  if (logFilePath) attachments.push({ type: "file", path: logFilePath });
+  if (screenshotFilePath) attachments.push({ type: "file", path: screenshotFilePath });
+
+  const result = await runCopilotSession({
+    workspacePath: process.cwd(),
     model,
-    systemMessage: `You are an autonomous coding agent fixing failing tests on PR #${prNumber}. Make minimal, targeted changes to fix the test failures.` + NARRATIVE_INSTRUCTION,
-    prompt,
-    writablePaths,
     tuning: t,
+    agentPrompt: systemPrompt,
+    userPrompt: prompt,
+    writablePaths,
+    createTools,
+    attachments,
+    excludedTools: ["dispatch_workflow", "close_issue", "label_issue", "post_discussion_comment"],
+    logger: { info: core.info, warning: core.warning, error: core.error, debug: core.debug },
   });
 
-  core.info(`Copilot SDK fix response received (${tokensUsed} tokens)`);
+  core.info(`Fix response received (${result.tokensIn + result.tokensOut} tokens)`);
 
   return {
     outcome: "fix-applied",
-    tokensUsed,
-    inputTokens,
-    outputTokens,
-    cost,
+    tokensUsed: result.tokensIn + result.tokensOut,
+    inputTokens: result.tokensIn,
+    outputTokens: result.tokensOut,
+    cost: 0,
     model,
     details: `Applied fix for ${failedChecks.length} failing check(s) on PR #${prNumber}`,
-    narrative: extractNarrative(resultContent, `Fixed ${failedChecks.length} failing check(s) on PR #${prNumber}.`),
+    narrative: result.narrative || extractNarrative(result.agentMessage, `Fixed ${failedChecks.length} failing check(s) on PR #${prNumber}.`),
   };
 }