@eldrforge/ai-service 0.1.10 → 0.1.11

package/dist/index.js

@@ -1082,17 +1082,17 @@ function createToolRegistry(context) {
 }
 function createCommitTools() {
   return [
-    createGetFileHistoryTool(),
-    createGetFileContentTool(),
-    createSearchCodebaseTool(),
-    createGetRelatedTestsTool(),
-    createGetFileDependenciesTool(),
-    createAnalyzeDiffSectionTool(),
-    createGetRecentCommitsTool(),
-    createGroupFilesByConcernTool()
+    createGetFileHistoryTool$1(),
+    createGetFileContentTool$1(),
+    createSearchCodebaseTool$1(),
+    createGetRelatedTestsTool$1(),
+    createGetFileDependenciesTool$1(),
+    createAnalyzeDiffSectionTool$1(),
+    createGetRecentCommitsTool$1(),
+    createGroupFilesByConcernTool$1()
   ];
 }
-function createGetFileHistoryTool() {
+function createGetFileHistoryTool$1() {
   return {
     name: "get_file_history",
     description: "Get git commit history for one or more files to understand their evolution and past changes",
@@ -1133,7 +1133,7 @@ function createGetFileHistoryTool() {
     }
   };
 }
-function createGetFileContentTool() {
+function createGetFileContentTool$1() {
   return {
     name: "get_file_content",
     description: "Get the complete current content of a file to understand context around changes",
@@ -1171,7 +1171,7 @@ function createGetFileContentTool() {
     }
   };
 }
-function createSearchCodebaseTool() {
+function createSearchCodebaseTool$1() {
   return {
     name: "search_codebase",
     description: "Search for code patterns, function names, or text across the codebase using git grep",
@@ -1215,7 +1215,7 @@ function createSearchCodebaseTool() {
     }
   };
 }
-function createGetRelatedTestsTool() {
+function createGetRelatedTestsTool$1() {
   return {
     name: "get_related_tests",
     description: "Find test files related to production files to understand what the code is supposed to do",
@@ -1261,7 +1261,7 @@ ${relatedTests.join("\n")}`;
     }
   };
 }
-function createGetFileDependenciesTool() {
+function createGetFileDependenciesTool$1() {
   return {
     name: "get_file_dependencies",
     description: "Find which files import or depend on the changed files to assess change impact",
@@ -1304,7 +1304,7 @@ ${output.stdout}`);
     }
   };
 }
-function createAnalyzeDiffSectionTool() {
+function createAnalyzeDiffSectionTool$1() {
   return {
     name: "analyze_diff_section",
     description: "Get expanded context around specific lines in a file to better understand changes",
@@ -1352,7 +1352,7 @@ ${section}`;
     }
   };
 }
-function createGetRecentCommitsTool() {
+function createGetRecentCommitsTool$1() {
   return {
     name: "get_recent_commits",
     description: "Get recent commits that modified the same files to understand recent work in this area",
@@ -1391,7 +1391,7 @@ function createGetRecentCommitsTool() {
     }
   };
 }
-function createGroupFilesByConcernTool() {
+function createGroupFilesByConcernTool$1() {
   return {
     name: "group_files_by_concern",
     description: "Analyze changed files and suggest logical groupings that might represent separate commits",
@@ -1462,8 +1462,8 @@ async function runAgenticCommit(config) {
   });
   const tools = createCommitTools();
   toolRegistry.registerAll(tools);
-  const systemPrompt = buildSystemPrompt();
-  const userMessage = buildUserMessage(changedFiles, diffContent, userDirection, logContext);
+  const systemPrompt = buildSystemPrompt$1();
+  const userMessage = buildUserMessage$1(changedFiles, diffContent, userDirection, logContext);
   const messages = [
     { role: "system", content: systemPrompt },
     { role: "user", content: userMessage }
@@ -1481,7 +1481,7 @@ async function runAgenticCommit(config) {
     openaiReasoning
   };
   const result = await runAgentic(agenticConfig);
-  const parsed = parseAgenticResult(result.finalMessage);
+  const parsed = parseAgenticResult$1(result.finalMessage);
   return {
     commitMessage: parsed.commitMessage,
     iterations: result.iterations,
@@ -1491,7 +1491,7 @@ async function runAgenticCommit(config) {
     toolMetrics: result.toolMetrics
   };
 }
-function buildSystemPrompt() {
+function buildSystemPrompt$1() {
   return `You are an expert software engineer tasked with generating meaningful commit messages.
 
 You have access to tools that let you investigate changes in detail:
@@ -1537,7 +1537,7 @@ Split 2:
 
 If changes should remain as one commit, do not include SUGGESTED_SPLITS section.`;
 }
-function buildUserMessage(changedFiles, diffContent, userDirection, logContext) {
+function buildUserMessage$1(changedFiles, diffContent, userDirection, logContext) {
   let message = `I have staged changes that need a commit message.
 
 Changed files (${changedFiles.length}):
@@ -1563,7 +1563,7 @@ Use the available tools to gather additional context as needed.
 If these changes should be split into multiple commits, suggest the groupings.`;
   return message;
 }
-function parseAgenticResult(finalMessage) {
+function parseAgenticResult$1(finalMessage) {
   const commitMatch = finalMessage.match(/COMMIT_MESSAGE:\s*\n([\s\S]*?)(?=\n\nSUGGESTED_SPLITS:|$)/);
   const commitMessage = commitMatch ? commitMatch[1].trim() : finalMessage.trim();
   const suggestedSplits = [];
@@ -1584,6 +1584,848 @@ function parseAgenticResult(finalMessage) {
   }
   return { commitMessage, suggestedSplits };
 }
+function createReleaseTools() {
+  return [
+    createGetFileHistoryTool(),
+    createGetFileContentTool(),
+    createSearchCodebaseTool(),
+    createGetRelatedTestsTool(),
+    createGetFileDependenciesTool(),
+    createAnalyzeDiffSectionTool(),
+    createGetRecentCommitsTool(),
+    createGroupFilesByConcernTool(),
+    createGetTagHistoryTool(),
+    createComparePreviousReleaseTool(),
+    createGetReleaseStatsTool(),
+    createGetBreakingChangesTool(),
+    createAnalyzeCommitPatternsTool()
+  ];
+}
+function createGetFileHistoryTool() {
+  return {
+    name: "get_file_history",
+    description: "Get git commit history for one or more files to understand their evolution and past changes",
+    parameters: {
+      type: "object",
+      properties: {
+        filePaths: {
+          type: "array",
+          description: "Array of file paths to get history for",
+          items: { type: "string", description: "File path" }
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of commits to return (default: 10)",
+          default: 10
+        },
+        format: {
+          type: "string",
+          description: 'Output format: "summary" for brief or "detailed" for full messages',
+          enum: ["summary", "detailed"],
+          default: "summary"
+        }
+      },
+      required: ["filePaths"]
+    },
+    execute: async (params, context) => {
+      const { filePaths, limit = 10, format = "summary" } = params;
+      const workingDir = context?.workingDirectory || process.cwd();
+      const formatArg = format === "detailed" ? "--format=%H%n%an (%ae)%n%ad%n%s%n%n%b%n---" : "--format=%h - %s (%an, %ar)";
+      const fileArgs = filePaths.join(" ");
+      const command = `git log ${formatArg} -n ${limit} -- ${fileArgs}`;
+      try {
+        const output = await run(command, { cwd: workingDir });
+        return output.stdout || "No history found for specified files";
+      } catch (error) {
+        throw new Error(`Failed to get file history: ${error.message}`);
+      }
+    }
+  };
+}
+function createGetFileContentTool() {
+  return {
+    name: "get_file_content",
+    description: "Get the complete current content of a file to understand context around changes",
+    parameters: {
+      type: "object",
+      properties: {
+        filePath: {
+          type: "string",
+          description: "Path to the file"
+        },
+        includeLineNumbers: {
+          type: "boolean",
+          description: "Include line numbers in output (default: false)",
+          default: false
+        }
+      },
+      required: ["filePath"]
+    },
+    execute: async (params, context) => {
+      const { filePath, includeLineNumbers = false } = params;
+      const storage = context?.storage;
+      if (!storage) {
+        throw new Error("Storage adapter not available in context");
+      }
+      try {
+        const content = await storage.readFile(filePath, "utf-8");
+        if (includeLineNumbers) {
+          const lines = content.split("\n");
+          return lines.map((line, idx) => `${idx + 1}: ${line}`).join("\n");
+        }
+        return content;
+      } catch (error) {
+        throw new Error(`Failed to read file: ${error.message}`);
+      }
+    }
+  };
+}
+function createSearchCodebaseTool() {
+  return {
+    name: "search_codebase",
+    description: "Search for code patterns, function names, or text across the codebase using git grep",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search pattern (can be plain text or regex)"
+        },
+        fileTypes: {
+          type: "array",
+          description: 'Limit search to specific file extensions (e.g., ["ts", "js"])',
+          items: { type: "string", description: "File extension" }
+        },
+        contextLines: {
+          type: "number",
+          description: "Number of context lines to show around matches (default: 2)",
+          default: 2
+        }
+      },
+      required: ["query"]
+    },
+    execute: async (params, context) => {
+      const { query, fileTypes, contextLines = 2 } = params;
+      const workingDir = context?.workingDirectory || process.cwd();
+      let command = `git grep -n -C ${contextLines} "${query}"`;
+      if (fileTypes && fileTypes.length > 0) {
+        const patterns = fileTypes.map((ext) => `'*.${ext}'`).join(" ");
+        command += ` -- ${patterns}`;
+      }
+      try {
+        const output = await run(command, { cwd: workingDir });
+        return output.stdout || "No matches found";
+      } catch (error) {
+        if (error.message.includes("exit code 1")) {
+          return "No matches found";
+        }
+        throw new Error(`Search failed: ${error.message}`);
+      }
+    }
+  };
+}
+function createGetRelatedTestsTool() {
+  return {
+    name: "get_related_tests",
+    description: "Find test files related to production files to understand what the code is supposed to do",
+    parameters: {
+      type: "object",
+      properties: {
+        filePaths: {
+          type: "array",
+          description: "Production file paths",
+          items: { type: "string", description: "File path" }
+        }
+      },
+      required: ["filePaths"]
+    },
+    execute: async (params, context) => {
+      const { filePaths } = params;
+      const storage = context?.storage;
+      if (!storage) {
+        throw new Error("Storage adapter not available in context");
+      }
+      const relatedTests = [];
+      for (const filePath of filePaths) {
+        const patterns = [
+          filePath.replace(/\.(ts|js|tsx|jsx)$/, ".test.$1"),
+          filePath.replace(/\.(ts|js|tsx|jsx)$/, ".spec.$1"),
+          filePath.replace("/src/", "/tests/").replace("/lib/", "/tests/"),
+          path.join("tests", filePath),
+          path.join("test", filePath)
+        ];
+        for (const pattern of patterns) {
+          try {
+            await storage.readFile(pattern, "utf-8");
+            relatedTests.push(pattern);
+          } catch {
+          }
+        }
+      }
+      if (relatedTests.length === 0) {
+        return "No related test files found";
+      }
+      return `Found related test files:
+${relatedTests.join("\n")}`;
+    }
+  };
+}
+function createGetFileDependenciesTool() {
+  return {
+    name: "get_file_dependencies",
+    description: "Find which files import or depend on the changed files to assess change impact",
+    parameters: {
+      type: "object",
+      properties: {
+        filePaths: {
+          type: "array",
+          description: "Files to analyze dependencies for",
+          items: { type: "string", description: "File path" }
+        }
+      },
+      required: ["filePaths"]
+    },
+    execute: async (params, context) => {
+      const { filePaths } = params;
+      const workingDir = context?.workingDirectory || process.cwd();
+      const results = [];
+      for (const filePath of filePaths) {
+        const fileName = path.basename(filePath, path.extname(filePath));
+        const searchPatterns = [
+          `from.*['"].*${fileName}`,
+          `import.*['"].*${fileName}`,
+          `require\\(['"].*${fileName}`
+        ];
+        for (const pattern of searchPatterns) {
+          try {
+            const command = `git grep -l "${pattern}"`;
+            const output = await run(command, { cwd: workingDir });
+            if (output.stdout) {
+              results.push(`Files importing ${filePath}:
+${output.stdout}`);
+              break;
+            }
+          } catch {
+          }
+        }
+      }
+      return results.length > 0 ? results.join("\n\n") : "No files found that import the specified files";
+    }
+  };
+}
+function createAnalyzeDiffSectionTool() {
+  return {
+    name: "analyze_diff_section",
+    description: "Get expanded context around specific lines in a file to better understand changes",
+    parameters: {
+      type: "object",
+      properties: {
+        filePath: {
+          type: "string",
+          description: "File containing the section to analyze"
+        },
+        startLine: {
+          type: "number",
+          description: "Starting line number"
+        },
+        endLine: {
+          type: "number",
+          description: "Ending line number"
+        },
+        contextLines: {
+          type: "number",
+          description: "Number of additional context lines to show before and after (default: 10)",
+          default: 10
+        }
+      },
+      required: ["filePath", "startLine", "endLine"]
+    },
+    execute: async (params, context) => {
+      const { filePath, startLine, endLine, contextLines = 10 } = params;
+      const storage = context?.storage;
+      if (!storage) {
+        throw new Error("Storage adapter not available in context");
+      }
+      try {
+        const content = await storage.readFile(filePath, "utf-8");
+        const lines = content.split("\n");
+        const actualStart = Math.max(0, startLine - contextLines - 1);
+        const actualEnd = Math.min(lines.length, endLine + contextLines);
+        const section = lines.slice(actualStart, actualEnd).map((line, idx) => `${actualStart + idx + 1}: ${line}`).join("\n");
+        return `Lines ${actualStart + 1}-${actualEnd} from ${filePath}:
+
+${section}`;
+      } catch (error) {
+        throw new Error(`Failed to analyze diff section: ${error.message}`);
+      }
+    }
+  };
+}
+function createGetRecentCommitsTool() {
+  return {
+    name: "get_recent_commits",
+    description: "Get recent commits that modified the same files to understand recent work in this area",
+    parameters: {
+      type: "object",
+      properties: {
+        filePaths: {
+          type: "array",
+          description: "Files to check for recent commits",
+          items: { type: "string", description: "File path" }
+        },
+        since: {
+          type: "string",
+          description: 'Time period to look back (e.g., "1 week ago", "2 days ago")',
+          default: "1 week ago"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of commits to return (default: 5)",
+          default: 5
+        }
+      },
+      required: ["filePaths"]
+    },
+    execute: async (params, context) => {
+      const { filePaths, since = "1 week ago", limit = 5 } = params;
+      const workingDir = context?.workingDirectory || process.cwd();
+      const fileArgs = filePaths.join(" ");
+      const command = `git log --format="%h - %s (%an, %ar)" --since="${since}" -n ${limit} -- ${fileArgs}`;
+      try {
+        const output = await run(command, { cwd: workingDir });
+        return output.stdout || `No commits found in the specified time period (${since})`;
+      } catch (error) {
+        throw new Error(`Failed to get recent commits: ${error.message}`);
+      }
+    }
+  };
+}
+function createGroupFilesByConcernTool() {
+  return {
+    name: "group_files_by_concern",
+    description: "Analyze changed files and suggest logical groupings that might represent separate concerns",
+    parameters: {
+      type: "object",
+      properties: {
+        filePaths: {
+          type: "array",
+          description: "All changed files to analyze",
+          items: { type: "string", description: "File path" }
+        }
+      },
+      required: ["filePaths"]
+    },
+    execute: async (params) => {
+      const { filePaths } = params;
+      const groups = {};
+      for (const filePath of filePaths) {
+        const dir = path.dirname(filePath);
+        const ext = path.extname(filePath);
+        const basename = path.basename(filePath, ext);
+        let category = "other";
+        if (basename.includes(".test") || basename.includes(".spec") || dir.includes("test")) {
+          category = "tests";
+        } else if (filePath.includes("package.json") || filePath.includes("package-lock.json")) {
+          category = "dependencies";
+        } else if (ext === ".md" || basename === "README") {
+          category = "documentation";
+        } else if (dir.includes("src") || dir.includes("lib")) {
+          category = `source:${dir.split("/").slice(0, 3).join("/")}`;
+        }
+        if (!groups[category]) {
+          groups[category] = [];
+        }
+        groups[category].push(filePath);
+      }
+      const output = Object.entries(groups).map(([category, files]) => {
+        return `${category} (${files.length} files):
+${files.map((f) => `  - ${f}`).join("\n")}`;
+      }).join("\n\n");
+      const groupCount = Object.keys(groups).length;
+      const suggestion = groupCount > 1 ? `
+
+Suggestion: These ${groupCount} groups represent different concerns in the release.` : "\n\nSuggestion: All files appear to be related to a single concern.";
+      return output + suggestion;
+    }
+  };
+}
+function createGetTagHistoryTool() {
+  return {
+    name: "get_tag_history",
+    description: "Get the history of previous release tags to understand release patterns and versioning",
+    parameters: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Number of recent tags to retrieve (default: 10)",
+          default: 10
+        },
+        pattern: {
+          type: "string",
+          description: 'Filter tags by pattern (e.g., "v*" for version tags)'
+        }
+      }
+    },
+    execute: async (params, context) => {
+      const { limit = 10, pattern } = params;
+      const workingDir = context?.workingDirectory || process.cwd();
+      let command = "git tag --sort=-creatordate";
+      if (pattern) {
+        command += ` -l "${pattern}"`;
+      }
+      command += ` | head -n ${limit}`;
+      try {
+        const output = await run(command, { cwd: workingDir });
+        if (!output.stdout) {
+          return "No tags found in repository";
+        }
+        const tags = output.stdout.trim().split("\n");
+        const detailedInfo = [];
+        for (const tag of tags) {
+          try {
+            const tagInfo = await run(`git show --quiet --format="%ci - %s" ${tag}`, { cwd: workingDir });
+            detailedInfo.push(`${tag}: ${tagInfo.stdout.trim()}`);
+          } catch {
+            detailedInfo.push(`${tag}: (no info available)`);
+          }
+        }
+        return `Recent release tags:
+${detailedInfo.join("\n")}`;
+      } catch (error) {
+        throw new Error(`Failed to get tag history: ${error.message}`);
+      }
+    }
+  };
+}
+function createComparePreviousReleaseTool() {
+  return {
+    name: "compare_previous_release",
+    description: "Compare this release with a previous release to understand what changed between versions",
+    parameters: {
+      type: "object",
+      properties: {
+        previousTag: {
+          type: "string",
+          description: "Previous release tag to compare against"
+        },
+        currentRef: {
+          type: "string",
+          description: "Current reference (default: HEAD)",
+          default: "HEAD"
+        },
+        statsOnly: {
+          type: "boolean",
+          description: "Return only statistics, not full diff (default: true)",
+          default: true
+        }
+      },
+      required: ["previousTag"]
+    },
+    execute: async (params, context) => {
+      const { previousTag, currentRef = "HEAD", statsOnly = true } = params;
+      const workingDir = context?.workingDirectory || process.cwd();
+      try {
+        const commitCountCmd = `git rev-list --count ${previousTag}..${currentRef}`;
+        const commitCount = await run(commitCountCmd, { cwd: workingDir });
+        const statsCmd = `git diff --stat ${previousTag}..${currentRef}`;
+        const stats = await run(statsCmd, { cwd: workingDir });
+        let result = `Comparison between ${previousTag} and ${currentRef}:
+
+`;
+        result += `Commits: ${commitCount.stdout.trim()}
+
+`;
+        result += `File changes:
+${stats.stdout}`;
+        if (!statsOnly) {
+          const logCmd = `git log --oneline ${previousTag}..${currentRef}`;
+          const log = await run(logCmd, { cwd: workingDir });
+          result += `
+
+Commit summary:
+${log.stdout}`;
+        }
+        return result;
+      } catch (error) {
+        throw new Error(`Failed to compare releases: ${error.message}`);
+      }
+    }
+  };
+}
+function createGetReleaseStatsTool() {
+  return {
+    name: "get_release_stats",
+    description: "Get comprehensive statistics about the release including contributors, file changes, and commit patterns",
+    parameters: {
+      type: "object",
+      properties: {
+        fromRef: {
+          type: "string",
+          description: "Starting reference for the release range"
+        },
+        toRef: {
+          type: "string",
+          description: "Ending reference for the release range (default: HEAD)",
+          default: "HEAD"
+        }
+      },
+      required: ["fromRef"]
+    },
+    execute: async (params, context) => {
+      const { fromRef, toRef = "HEAD" } = params;
+      const workingDir = context?.workingDirectory || process.cwd();
+      try {
+        const results = [];
+        const commitCount = await run(`git rev-list --count ${fromRef}..${toRef}`, { cwd: workingDir });
+        results.push(`Total commits: ${commitCount.stdout.trim()}`);
+        const contributors = await run(
+          `git shortlog -sn ${fromRef}..${toRef}`,
+          { cwd: workingDir }
+        );
+        results.push(`
+Contributors:
+${contributors.stdout}`);
+        const fileStats = await run(
+          `git diff --shortstat ${fromRef}..${toRef}`,
+          { cwd: workingDir }
+        );
+        results.push(`
+File changes: ${fileStats.stdout.trim()}`);
+        const topFiles = await run(
+          `git diff --stat ${fromRef}..${toRef} | sort -k2 -rn | head -n 10`,
+          { cwd: workingDir }
+        );
+        results.push(`
+Top 10 most changed files:
+${topFiles.stdout}`);
+        return results.join("\n");
+      } catch (error) {
+        throw new Error(`Failed to get release stats: ${error.message}`);
+      }
+    }
+  };
+}
+function createGetBreakingChangesTool() {
+  return {
+    name: "get_breaking_changes",
+    description: "Search for potential breaking changes by looking for specific patterns in commits and diffs",
+    parameters: {
+      type: "object",
+      properties: {
+        fromRef: {
+          type: "string",
+          description: "Starting reference for the release range"
+        },
+        toRef: {
+          type: "string",
+          description: "Ending reference for the release range (default: HEAD)",
+          default: "HEAD"
+        }
+      },
+      required: ["fromRef"]
+    },
+    execute: async (params, context) => {
+      const { fromRef, toRef = "HEAD" } = params;
+      const workingDir = context?.workingDirectory || process.cwd();
+      const results = [];
+      try {
+        const breakingCommits = await run(
+          `git log --grep="BREAKING CHANGE" --oneline ${fromRef}..${toRef}`,
+          { cwd: workingDir }
+        );
+        if (breakingCommits.stdout) {
+          results.push(`Commits with BREAKING CHANGE:
+${breakingCommits.stdout}`);
+        }
+        const removedExports = await run(
+          `git diff ${fromRef}..${toRef} | grep "^-export"`,
+          { cwd: workingDir }
+        );
+        if (removedExports.stdout) {
+          results.push(`
+Removed exports (potential breaking):
+${removedExports.stdout}`);
+        }
+        const changedSignatures = await run(
+          `git diff ${fromRef}..${toRef} | grep -E "^[-+].*function|^[-+].*const.*=.*=>|^[-+].*interface|^[-+].*type.*="`,
+          { cwd: workingDir }
+        );
+        if (changedSignatures.stdout) {
+          results.push(`
+Changed function/type signatures (review for breaking changes):
+${changedSignatures.stdout.split("\n").slice(0, 20).join("\n")}`);
+        }
+        if (results.length === 0) {
+          return "No obvious breaking changes detected. Manual review recommended for API changes.";
+        }
+        return results.join("\n\n");
+      } catch {
+        if (results.length > 0) {
+          return results.join("\n\n");
+        }
+        return "No obvious breaking changes detected. Manual review recommended for API changes.";
+      }
+    }
+  };
+}
+function createAnalyzeCommitPatternsTool() {
+  return {
+    name: "analyze_commit_patterns",
+    description: "Analyze commit messages to identify patterns and themes in the release",
+    parameters: {
+      type: "object",
+      properties: {
+        fromRef: {
+          type: "string",
+          description: "Starting reference for the release range"
+        },
+        toRef: {
+          type: "string",
+          description: "Ending reference for the release range (default: HEAD)",
+          default: "HEAD"
+        }
+      },
+      required: ["fromRef"]
+    },
+    execute: async (params, context) => {
+      const { fromRef, toRef = "HEAD" } = params;
+      const workingDir = context?.workingDirectory || process.cwd();
+      try {
+        const results = [];
+        const commits = await run(
+          `git log --format="%s" ${fromRef}..${toRef}`,
+          { cwd: workingDir }
+        );
+        const messages = commits.stdout.trim().split("\n");
+        const types = {};
+        const keywords = {};
+        for (const msg of messages) {
+          const conventionalMatch = msg.match(/^(\w+)(\(.+?\))?:/);
+          if (conventionalMatch) {
+            const type = conventionalMatch[1];
+            types[type] = (types[type] || 0) + 1;
+          }
+          const words = msg.toLowerCase().match(/\b\w{5,}\b/g) || [];
+          for (const word of words) {
+            keywords[word] = (keywords[word] || 0) + 1;
+          }
+        }
+        if (Object.keys(types).length > 0) {
+          results.push("Commit types:");
+          const sortedTypes = Object.entries(types).sort((a, b) => b[1] - a[1]).map(([type, count]) => `  ${type}: ${count}`).join("\n");
+          results.push(sortedTypes);
+        }
+        const topKeywords = Object.entries(keywords).sort((a, b) => b[1] - a[1]).slice(0, 15).map(([word, count]) => `  ${word}: ${count}`).join("\n");
+        if (topKeywords) {
+          results.push("\nTop keywords in commits:");
+          results.push(topKeywords);
+        }
+        return results.join("\n");
+      } catch (error) {
+        throw new Error(`Failed to analyze commit patterns: ${error.message}`);
+      }
+    }
+  };
+}
+async function runAgenticRelease(config) {
+  const {
+    fromRef,
+    toRef,
+    logContent,
+    diffContent,
+    milestoneIssues,
+    releaseFocus,
+    userContext,
+    model = "gpt-4o",
+    maxIterations = 30,
+    debug = false,
+    debugRequestFile,
+    debugResponseFile,
+    storage,
+    logger: logger2,
+    openaiReasoning
+  } = config;
+  const toolRegistry = createToolRegistry({
+    workingDirectory: process.cwd(),
+    storage,
+    logger: logger2
+  });
+  const tools = createReleaseTools();
+  toolRegistry.registerAll(tools);
+  const systemPrompt = buildSystemPrompt();
+  const userMessage = buildUserMessage({
+    fromRef,
+    toRef,
+    logContent,
+    diffContent,
+    milestoneIssues,
+    releaseFocus,
+    userContext
+  });
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userMessage }
+  ];
+  const agenticConfig = {
+    messages,
+    tools: toolRegistry,
+    model,
+    maxIterations,
+    debug,
+    debugRequestFile,
+    debugResponseFile,
+    storage,
+    logger: logger2,
+    openaiReasoning
+  };
+  const result = await runAgentic(agenticConfig);
+  const parsed = parseAgenticResult(result.finalMessage);
+  return {
+    releaseNotes: parsed.releaseNotes,
+    iterations: result.iterations,
+    toolCallsExecuted: result.toolCallsExecuted,
+    conversationHistory: result.conversationHistory,
+    toolMetrics: result.toolMetrics
+  };
+}
+function buildSystemPrompt() {
+  return `You are an expert software engineer and technical writer tasked with generating comprehensive, thoughtful release notes.
+
+You have access to tools that let you investigate the release in detail:
+- get_file_history: View commit history for specific files
+- get_file_content: Read full file contents to understand context
+- search_codebase: Search for patterns across the codebase
+- get_related_tests: Find test files to understand functionality
+- get_file_dependencies: Understand file dependencies and impact
+- analyze_diff_section: Get expanded context around specific changes
+- get_recent_commits: See recent commits to the same files
+- group_files_by_concern: Identify logical groupings of changes
+- get_tag_history: View previous release tags and patterns
+- compare_previous_release: Compare with previous releases
+- get_release_stats: Get comprehensive statistics about the release
+- get_breaking_changes: Identify potential breaking changes
+- analyze_commit_patterns: Identify themes and patterns in commits
+
+Your process should be:
+1. Analyze the commit log and diff to understand the overall scope of changes
+2. Use tools strategically to investigate significant changes that need more context
+3. Look at previous releases to understand how this release fits into the project's evolution
+4. Identify patterns, themes, and connections between changes
+5. Check for breaking changes and significant architectural shifts
+6. Understand the "why" behind changes by examining commit messages, issues, and code
+7. Synthesize findings into comprehensive, thoughtful release notes
+
+Guidelines:
+- Use tools strategically - focus on understanding significant changes
+- Look at test changes to understand intent and functionality
+- Check previous releases to provide context and compare scope
+- Identify patterns and themes across multiple commits
+- Consider the audience and what context they need
+- Be thorough and analytical, especially for large releases
+- Follow the release notes format and best practices provided
+
+Output format:
+When you're ready to provide the final release notes, format them as JSON:
+
+RELEASE_NOTES:
+{
+  "title": "A concise, single-line title capturing the most significant changes",
+  "body": "The detailed release notes in Markdown format, following best practices for structure, depth, and analysis"
+}
+
+The release notes should:
+- Demonstrate genuine understanding of the changes
+- Provide context and explain implications
+- Connect related changes to reveal patterns
+- Be substantial and analytical, not formulaic
+- Sound like they were written by a human who studied the changes
+- Be grounded in actual commits and issues (no hallucinations)`;
+}
+function buildUserMessage(params) {
+  const { fromRef, toRef, logContent, diffContent, milestoneIssues, releaseFocus, userContext } = params;
+  let message = `I need comprehensive release notes for changes from ${fromRef} to ${toRef}.
+
+## Commit Log
+${logContent}
+
+## Diff Summary
+${diffContent}`;
+  if (milestoneIssues) {
+    message += `
+
+## Resolved Issues from Milestone
+${milestoneIssues}`;
+  }
+  if (releaseFocus) {
+    message += `
+
+## Release Focus
+${releaseFocus}
+
+This is the PRIMARY GUIDE for how to frame and structure the release notes. Use this to determine emphasis and narrative.`;
+  }
+  if (userContext) {
+    message += `
+
+## Additional Context
+${userContext}`;
+  }
+  message += `
+
+Please investigate these changes thoroughly and generate comprehensive release notes that:
+1. Demonstrate deep understanding of what changed and why
+2. Provide context about how changes relate to each other
+3. Explain implications for users and developers
+4. Connect this release to previous releases and project evolution
+5. Identify any breaking changes or significant architectural shifts
+6. Follow best practices for technical writing and release notes
+
+Use the available tools to gather additional context as needed. Take your time to understand the changes deeply before writing the release notes.`;
+  return message;
+}
+function parseAgenticResult(finalMessage) {
+  const jsonMatch = finalMessage.match(/RELEASE_NOTES:\s*\n([\s\S]*)/);
+  if (jsonMatch) {
+    try {
+      const jsonStr = jsonMatch[1].trim();
+      const parsed = JSON.parse(jsonStr);
+      if (parsed.title && parsed.body) {
+        return {
+          releaseNotes: {
+            title: parsed.title,
+            body: parsed.body
+          }
+        };
+      }
+    } catch {
+    }
+  }
+  const lines = finalMessage.split("\n");
+  let title = "";
+  let body = "";
+  let inBody = false;
+  for (const line of lines) {
+    if (!title && line.trim() && !line.startsWith("#")) {
+      title = line.trim();
+    } else if (title && line.trim()) {
+      inBody = true;
+    }
+    if (inBody) {
+      body += line + "\n";
+    }
+  }
+  if (!title || !body) {
+    title = "Release Notes";
+    body = finalMessage;
+  }
+  return {
+    releaseNotes: {
+      title: title.trim(),
+      body: body.trim()
+    }
+  };
+}
 export {
   AgenticExecutor,
   OpenAIError,
@@ -1597,6 +2439,7 @@ export {
   createCompletionWithRetry,
   createNoOpLogger,
   createReleasePrompt,
+  createReleaseTools,
   createReviewPrompt,
   createSecureTempFile,
   createToolRegistry,
@@ -1612,6 +2455,7 @@ export {
   requireTTY,
   runAgentic,
   runAgenticCommit,
+  runAgenticRelease,
   setLogger,
   transcribeAudio,
   tryLoadWinston