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

package/src/actions/agentic-step/tasks/maintain-features.js

@@ -2,13 +2,41 @@
 // Copyright (C) 2025-2026 Polycode Limited
 // tasks/maintain-features.js — Feature lifecycle management
 //
-// Reviews existing features, creates new ones from mission/library analysis,
-// prunes completed/irrelevant features, and ensures quality.
+// Uses runCopilotSession with lean prompts: the model reads feature files,
+// library docs, and issues via tools to maintain the feature set.
 
-import { existsSync } from "fs";
-import { runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection, extractFeatureSummary, extractNarrative, NARRATIVE_INSTRUCTION } from "../copilot.js";
+import * as core from "@actions/core";
+import { existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+import { readOptionalFile, formatPathsSection, extractNarrative, NARRATIVE_INSTRUCTION } from "../copilot.js";
+import { runCopilotSession } from "../../../copilot/copilot-session.js";
+import { createGitHubTools } from "../../../copilot/github-tools.js";
 import { checkWipLimit } from "../safety.js";
 
+/**
+ * Build a file listing summary (names + sizes, not content).
+ */
+function buildFileListing(dirPath, extension) {
+  if (!dirPath || !existsSync(dirPath)) return [];
+  try {
+    const files = readdirSync(dirPath, { recursive: true });
+    return files
+      .filter((f) => String(f).endsWith(extension))
+      .map((f) => {
+        const fullPath = join(dirPath, String(f));
+        try {
+          const stat = statSync(fullPath);
+          return `${f} (~${Math.round(stat.size / 40)} lines, ${stat.size} bytes)`;
+        } catch {
+          return String(f);
+        }
+      })
+      .slice(0, 30);
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Maintain the feature set — create, update, or prune feature files.
  *
@@ -16,7 +44,7 @@ import { checkWipLimit } from "../safety.js";
  * @returns {Promise<Object>} Result with outcome, tokensUsed, model
  */
 export async function maintainFeatures(context) {
-  const { config, instructions, writablePaths, model, octokit, repo } = context;
+  const { config, instructions, writablePaths, model, octokit, repo, logFilePath, screenshotFilePath } = context;
   const t = config.tuning || {};
 
   // Check mission-complete signal (skip in maintenance mode)
@@ -31,35 +59,9 @@ export async function maintainFeatures(context) {
   }
 
   const mission = readOptionalFile(config.paths.mission.path);
-  const featuresPath = config.paths.features.path;
   const featureLimit = config.paths.features.limit;
-  const features = scanDirectory(featuresPath, ".md", { fileLimit: t.featuresScan || 10 });
-
-  // Sort features: incomplete (has unchecked items) first, then by name
-  features.sort((a, b) => {
-    const aIncomplete = /- \[ \]/.test(a.content) ? 0 : 1;
-    const bIncomplete = /- \[ \]/.test(b.content) ? 0 : 1;
-    return aIncomplete - bIncomplete || a.name.localeCompare(b.name);
-  });
-  const libraryDocs = scanDirectory(config.paths.library.path, ".md", {
-    contentLimit: t.documentSummary || 1000,
-  });
-
-  // Filter closed issues to only those created after the most recent init
-  const initTimestamp = config.init?.timestamp || null;
-  const initEpoch = initTimestamp ? new Date(initTimestamp).getTime() : 0;
-
-  const { data: closedIssuesRaw } = await octokit.rest.issues.listForRepo({
-    ...repo,
-    state: "closed",
-    per_page: t.issuesScan || 20,
-    sort: "updated",
-    direction: "desc",
-  });
-  const closedIssues = initEpoch > 0
-    ? closedIssuesRaw.filter((i) => new Date(i.created_at).getTime() >= initEpoch)
-    : closedIssuesRaw;
-
+  const featureFiles = buildFileListing(config.paths.features.path, ".md");
+  const libraryFiles = buildFileListing(config.paths.library.path, ".md");
   const agentInstructions = instructions || "Maintain the feature set by creating, updating, or pruning features.";
 
   const prompt = [
@@ -69,17 +71,16 @@ export async function maintainFeatures(context) {
     "## Mission",
     mission,
     "",
-    `## Current Features (${features.length}/${featureLimit} max)`,
-    ...features.map((f) => `### ${f.name}\n${f.content}`),
-    "",
-    libraryDocs.length > 0 ? `## Library Documents (${libraryDocs.length})` : "",
-    ...libraryDocs.map((d) => `### ${d.name}\n${d.content}`),
+    `## Current Features (${featureFiles.length}/${featureLimit} max)`,
+    featureFiles.length > 0 ? featureFiles.join(", ") : "none",
     "",
-    `## Recently Closed Issues (${closedIssues.length}${initTimestamp ? `, since init ${initTimestamp}` : ""})`,
-    ...closedIssues.slice(0, Math.floor((t.issuesScan || 20) / 2)).map((i) => `- #${i.number}: ${i.title}`),
+    `## Library Documents (${libraryFiles.length})`,
+    libraryFiles.length > 0 ? libraryFiles.join(", ") : "none",
     "",
     "## Your Task",
-    `1. Review each existing feature — if it is already implemented or irrelevant, delete it.`,
+    "Use read_file to read each feature file and evaluate it.",
+    "Use list_issues to see closed issues that indicate completed features.",
+    "1. Review each existing feature — if it is already implemented or irrelevant, delete it.",
     `2. If there are fewer than ${featureLimit} features, create new features aligned with the mission.`,
     "3. Ensure each feature has clear, testable acceptance criteria.",
     "",
@@ -90,23 +91,39 @@ export async function maintainFeatures(context) {
     "- Feature files must be markdown with a descriptive filename (e.g. HTTP_SERVER.md)",
   ].join("\n");
 
-  const { content: resultContent, tokensUsed, inputTokens, outputTokens, cost } = await runCopilotTask({
+  const systemPrompt =
+    "You are a feature lifecycle manager. Create, update, and prune feature specification files to keep the project focused on its mission." +
+    NARRATIVE_INSTRUCTION;
+
+  const createTools = (defineTool, _wp, logger) => {
+    return createGitHubTools(octokit, repo, defineTool, logger);
+  };
+
+  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 feature lifecycle manager. Create, update, and prune feature specification files to keep the project focused on its mission." + NARRATIVE_INSTRUCTION,
-    prompt,
-    writablePaths,
     tuning: t,
+    agentPrompt: systemPrompt,
+    userPrompt: prompt,
+    writablePaths,
+    createTools,
+    attachments,
+    excludedTools: ["dispatch_workflow", "close_issue", "label_issue", "post_discussion_comment", "run_tests"],
+    logger: { info: core.info, warning: core.warning, error: core.error, debug: core.debug },
   });
 
   return {
     outcome: "features-maintained",
-    tokensUsed,
-    inputTokens,
-    outputTokens,
-    cost,
+    tokensUsed: result.tokensIn + result.tokensOut,
+    inputTokens: result.tokensIn,
+    outputTokens: result.tokensOut,
+    cost: 0,
     model,
-    details: `Maintained features (${features.length} existing, limit ${featureLimit})`,
-    narrative: extractNarrative(resultContent, `Maintained ${features.length} features (limit ${featureLimit}).`),
+    details: `Maintained features (${featureFiles.length} existing, limit ${featureLimit})`,
+    narrative: result.narrative || extractNarrative(result.agentMessage, `Maintained ${featureFiles.length} features (limit ${featureLimit}).`),
   };
 }

package/src/actions/agentic-step/tasks/maintain-library.js

@@ -2,12 +2,38 @@
 // Copyright (C) 2025-2026 Polycode Limited
 // tasks/maintain-library.js — Library and knowledge management
 //
-// Crawls SOURCES.md, updates library documents, maintains the knowledge base
-// that provides context for feature generation and issue resolution.
+// Uses runCopilotSession with lean prompts: the model reads sources, library docs,
+// and web content via tools to maintain the knowledge base.
 
 import * as core from "@actions/core";
-import { existsSync } from "fs";
-import { runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection, extractNarrative, NARRATIVE_INSTRUCTION } from "../copilot.js";
+import { existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+import { readOptionalFile, formatPathsSection, extractNarrative, NARRATIVE_INSTRUCTION } from "../copilot.js";
+import { runCopilotSession } from "../../../copilot/copilot-session.js";
+
+/**
+ * Build a file listing summary (names + sizes, not content).
+ */
+function buildFileListing(dirPath, extension) {
+  if (!dirPath || !existsSync(dirPath)) return [];
+  try {
+    const files = readdirSync(dirPath, { recursive: true });
+    return files
+      .filter((f) => String(f).endsWith(extension))
+      .map((f) => {
+        const fullPath = join(dirPath, String(f));
+        try {
+          const stat = statSync(fullPath);
+          return `${f} (~${Math.round(stat.size / 40)} lines, ${stat.size} bytes)`;
+        } catch {
+          return String(f);
+        }
+      })
+      .slice(0, 30);
+  } catch {
+    return [];
+  }
+}
 
 /**
  * Maintain the library of knowledge documents from source URLs.
@@ -16,7 +42,7 @@ import { runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection, ex
  * @returns {Promise<Object>} Result with outcome, tokensUsed, model
  */
 export async function maintainLibrary(context) {
-  const { config, instructions, writablePaths, model } = context;
+  const { config, instructions, writablePaths, model, logFilePath, screenshotFilePath } = context;
   const t = config.tuning || {};
 
   // Check mission-complete signal (skip in maintenance mode)
@@ -32,7 +58,7 @@ export async function maintainLibrary(context) {
 
   const libraryPath = config.paths.library.path;
   const libraryLimit = config.paths.library.limit;
-  const libraryDocs = scanDirectory(libraryPath, ".md", { contentLimit: t.documentSummary || 500 });
+  const libraryFiles = buildFileListing(libraryPath, ".md");
 
   const agentInstructions = instructions || "Maintain the library by updating documents from sources.";
 
@@ -66,10 +92,11 @@ export async function maintainLibrary(context) {
       "## Sources",
       sources,
       "",
-      `## Current Library Documents (${libraryDocs.length}/${libraryLimit} max)`,
-      ...libraryDocs.map((d) => `### ${d.name}\n${d.content}`),
+      `## Current Library Documents (${libraryFiles.length}/${libraryLimit} max)`,
+      libraryFiles.length > 0 ? libraryFiles.join(", ") : "none",
       "",
       "## Your Task",
+      "Use read_file to read existing library documents.",
       "1. Read each URL in SOURCES.md and extract technical content.",
       "2. Create or update library documents based on the source content.",
       "3. Remove library documents that no longer have corresponding sources.",
@@ -81,28 +108,39 @@ export async function maintainLibrary(context) {
     ].join("\n");
   }
 
-  const { content: resultContent, tokensUsed, inputTokens, outputTokens, cost } = await runCopilotTask({
+  const systemPrompt =
+    "You are a knowledge librarian. Maintain a library of technical documents extracted from web sources." +
+    NARRATIVE_INSTRUCTION;
+
+  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 knowledge librarian. Maintain a library of technical documents extracted from web sources." + NARRATIVE_INSTRUCTION,
-    prompt,
-    writablePaths,
     tuning: t,
+    agentPrompt: systemPrompt,
+    userPrompt: prompt,
+    writablePaths,
+    attachments,
+    excludedTools: ["dispatch_workflow", "close_issue", "label_issue", "post_discussion_comment", "run_tests"],
+    logger: { info: core.info, warning: core.warning, error: core.error, debug: core.debug },
   });
 
   const outcomeLabel = hasUrls ? "library-maintained" : "sources-discovered";
   const detailsMsg = hasUrls
-    ? `Maintained library (${libraryDocs.length} docs, limit ${libraryLimit})`
+    ? `Maintained library (${libraryFiles.length} docs, limit ${libraryLimit})`
     : `Discovered sources for SOURCES.md from mission`;
 
   return {
     outcome: outcomeLabel,
-    tokensUsed,
-    inputTokens,
-    outputTokens,
-    cost,
+    tokensUsed: result.tokensIn + result.tokensOut,
+    inputTokens: result.tokensIn,
+    outputTokens: result.tokensOut,
+    cost: 0,
     model,
     details: detailsMsg,
-    narrative: extractNarrative(resultContent, detailsMsg),
+    narrative: result.narrative || extractNarrative(result.agentMessage, detailsMsg),
   };
 }

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

@@ -2,12 +2,14 @@
 // Copyright (C) 2025-2026 Polycode Limited
 // tasks/resolve-issue.js — Issue → code → PR
 //
-// Given an issue number, reads the issue, generates code using the Copilot SDK,
-// validates with tests, and creates a PR.
+// Uses runCopilotSession with lean prompts: the model reads source files,
+// writes code, and runs tests via tools.
 
 import * as core from "@actions/core";
 import { checkAttemptLimit, checkWipLimit, isIssueResolved } from "../safety.js";
-import { runCopilotTask, readOptionalFile, formatPathsSection, extractNarrative, NARRATIVE_INSTRUCTION } from "../copilot.js";
+import { readOptionalFile, formatPathsSection, extractNarrative, NARRATIVE_INSTRUCTION } from "../copilot.js";
+import { runCopilotSession } from "../../../copilot/copilot-session.js";
+import { createGitHubTools, createGitTools } from "../../../copilot/github-tools.js";
 
 /**
  * Resolve a GitHub issue by generating code and creating a PR.
@@ -16,7 +18,7 @@ import { runCopilotTask, readOptionalFile, formatPathsSection, extractNarrative,
  * @returns {Promise<Object>} Result with outcome, prNumber, tokensUsed, model
  */
 export async function resolveIssue(context) {
-  const { octokit, repo, config, issueNumber, instructions, writablePaths, testCommand, model } = context;
+  const { octokit, repo, config, issueNumber, instructions, writablePaths, testCommand, model, logFilePath, screenshotFilePath } = context;
 
   if (!issueNumber) {
     throw new Error("resolve-issue task requires issue-number input");
@@ -57,7 +59,6 @@ export async function resolveIssue(context) {
 
   const contributing = readOptionalFile(config.paths.contributing.path);
   const agentInstructions = instructions || "Resolve the GitHub issue by writing code that satisfies the requirements.";
-  const readOnlyPaths = config.readOnlyPaths;
 
   const prompt = [
     "## Instructions",
@@ -71,34 +72,58 @@ export async function resolveIssue(context) {
     comments.length > 0 ? "## Issue Comments" : "",
     ...comments.map((c) => `**${c.user.login}:** ${c.body}`),
     "",
-    formatPathsSection(writablePaths, readOnlyPaths, config),
+    "## Your Task",
+    "Read the source files you need (use read_file tool).",
+    "Write code to resolve this issue, then run run_tests to verify.",
+    "",
+    formatPathsSection(writablePaths, config.readOnlyPaths, config),
     "",
     "## Constraints",
-    `- Run \`${testCommand}\` to validate your changes`,
+    `- Run \`${testCommand}\` via run_tests to validate your changes`,
+    "- Use read_file to read source files (don't guess at contents)",
     contributing ? `\n## Contributing Guidelines\n${contributing}` : "",
   ].join("\n");
 
   const t = config.tuning || {};
-  const { content: resultContent, tokensUsed, inputTokens, outputTokens, cost } = await runCopilotTask({
+  const systemPrompt =
+    `You are an autonomous coding agent resolving GitHub issue #${issueNumber}. Write clean, tested code. Only modify files listed under "Writable" paths. Read-only paths are for context only.` +
+    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 resolving GitHub issue #${issueNumber}. Write clean, tested code. Only modify files listed under "Writable" paths. Read-only paths are for context only.` + 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 response received (${tokensUsed} tokens)`);
+  core.info(`Issue resolution completed (${result.tokensIn + result.tokensOut} tokens)`);
 
   return {
     outcome: "code-generated",
     prNumber: null,
-    tokensUsed,
-    inputTokens,
-    outputTokens,
-    cost,
+    tokensUsed: result.tokensIn + result.tokensOut,
+    inputTokens: result.tokensIn,
+    outputTokens: result.tokensOut,
+    cost: 0,
     model,
     commitUrl: null,
-    details: `Generated code for issue #${issueNumber}: ${resultContent.substring(0, 200)}`,
-    narrative: extractNarrative(resultContent, `Generated code for issue #${issueNumber}.`),
+    details: `Generated code for issue #${issueNumber}: ${(result.agentMessage || "").substring(0, 200)}`,
+    narrative: result.narrative || extractNarrative(result.agentMessage, `Generated code for issue #${issueNumber}.`),
   };
 }