@eldrforge/ai-service 0.1.9 → 0.1.11

package/dist/index.js

@@ -1,5 +1,5 @@
 import { OpenAI } from "openai";
-import { safeJsonParse } from "@eldrforge/git-tools";
+import { safeJsonParse, run } from "@eldrforge/git-tools";
 import fs$1 from "fs";
 import { spawnSync } from "child_process";
 import * as path from "path";
@@ -146,6 +146,10 @@ async function createCompletion(messages, options = { model: "gpt-4o-mini" }) {
       max_completion_tokens: maxCompletionTokens,
       response_format: options.responseFormat
     };
+    if (options.tools && options.tools.length > 0) {
+      apiOptions.tools = options.tools;
+      apiOptions.tool_choice = options.toolChoice || "auto";
+    }
     if (options.openaiReasoning && (modelToUse.includes("gpt-5") || modelToUse.includes("o3"))) {
       apiOptions.reasoning_effort = options.openaiReasoning;
     }
@@ -178,9 +182,26 @@ async function createCompletion(messages, options = { model: "gpt-4o-mini" }) {
       await options.storage.writeTemp(debugFile, JSON.stringify(completion, null, 2));
       logger2.debug("Wrote response debug file to %s", debugFile);
     }
-    const response = completion.choices[0]?.message?.content?.trim();
+    const message = completion.choices[0]?.message;
+    if (!message) {
+      throw new OpenAIError("No response message received from OpenAI");
+    }
+    if (options.tools && options.tools.length > 0) {
+      const elapsedTimeFormatted2 = elapsedTime >= 1e3 ? `${(elapsedTime / 1e3).toFixed(1)}s` : `${elapsedTime}ms`;
+      logger2.info("   Time: %s", elapsedTimeFormatted2);
+      if (completion.usage) {
+        logger2.info(
+          "   Token usage: %s prompt + %s completion = %s total",
+          completion.usage.prompt_tokens?.toLocaleString() || "?",
+          completion.usage.completion_tokens?.toLocaleString() || "?",
+          completion.usage.total_tokens?.toLocaleString() || "?"
+        );
+      }
+      return message;
+    }
+    const response = message.content?.trim();
     if (!response) {
-      throw new OpenAIError("No response received from OpenAI");
+      throw new OpenAIError("No response content received from OpenAI");
     }
     const responseSize = response.length;
     const responseSizeKB = (responseSize / 1024).toFixed(2);
@@ -795,18 +816,1633 @@ const createReviewPrompt = async ({ overridePaths: _overridePaths, overrides: _o
   }
   return recipe(basePath).persona({ path: "personas/you.md" }).instructions({ path: "instructions/review.md" }).overridePaths(_overridePaths ?? []).overrides(_overrides ?? true).content(...contentItems).context(...contextItems).cook();
 };
+class AgenticExecutor {
+  logger;
+  toolMetrics = [];
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  /**
+   * Run the agentic loop
+   */
+  async run(config) {
+    const {
+      messages: initialMessages,
+      tools,
+      model = "gpt-4o",
+      maxIterations = 10,
+      debug = false,
+      debugRequestFile,
+      debugResponseFile,
+      storage,
+      logger: logger2,
+      openaiReasoning = false
+    } = config;
+    const messages = [...initialMessages];
+    let iterations = 0;
+    let toolCallsExecuted = 0;
+    this.log("Starting agentic loop", { maxIterations, toolCount: tools.count() });
+    while (iterations < maxIterations) {
+      iterations++;
+      this.log(`Iteration ${iterations}/${maxIterations}`);
+      const response = await createCompletionWithRetry(
+        messages,
+        {
+          model,
+          openaiReasoning: openaiReasoning || void 0,
+          debug,
+          debugRequestFile: debugRequestFile ? `${debugRequestFile}-iter${iterations}` : void 0,
+          debugResponseFile: debugResponseFile ? `${debugResponseFile}-iter${iterations}` : void 0,
+          storage,
+          logger: logger2,
+          tools: tools.toOpenAIFormat()
+        }
+      );
+      const message = typeof response === "string" ? { content: response } : response;
+      const toolCalls = message.tool_calls || [];
+      if (toolCalls.length === 0) {
+        const finalContent = message.content || "";
+        this.log("Agent completed without tool calls", { iterations, toolCallsExecuted });
+        messages.push({
+          role: "assistant",
+          content: finalContent
+        });
+        return {
+          finalMessage: finalContent,
+          iterations,
+          toolCallsExecuted,
+          conversationHistory: messages,
+          toolMetrics: this.toolMetrics
+        };
+      }
+      messages.push({
+        role: "assistant",
+        content: message.content || null,
+        tool_calls: toolCalls
+      });
+      this.log(`Executing ${toolCalls.length} tool call(s)`);
+      for (const toolCall of toolCalls) {
+        const startTime = Date.now();
+        const toolName = toolCall.function.name;
+        try {
+          this.log(`Executing tool: ${toolName}`, toolCall.function.arguments);
+          if (this.logger?.info) {
+            this.logger.info(`🔧 Running tool: ${toolName}`);
+          }
+          const args = JSON.parse(toolCall.function.arguments);
+          const result = await tools.execute(toolName, args);
+          const duration = Date.now() - startTime;
+          messages.push({
+            role: "tool",
+            tool_call_id: toolCall.id,
+            content: this.formatToolResult({ id: toolCall.id, name: toolName, result })
+          });
+          toolCallsExecuted++;
+          this.toolMetrics.push({
+            name: toolName,
+            success: true,
+            duration,
+            iteration: iterations,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          this.log(`Tool ${toolName} succeeded in ${duration}ms`);
+          if (this.logger?.info) {
+            this.logger.info(`✅ Tool ${toolName} completed (${duration}ms)`);
+          }
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const errorMessage = error.message || String(error);
+          this.log(`Tool ${toolName} failed: ${errorMessage}`);
+          this.toolMetrics.push({
+            name: toolName,
+            success: false,
+            duration,
+            error: errorMessage,
+            iteration: iterations,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          if (this.logger?.warn) {
+            this.logger.warn(`❌ Tool ${toolName} failed: ${errorMessage}`);
+          }
+          messages.push({
+            role: "tool",
+            tool_call_id: toolCall.id,
+            content: `Tool execution failed: ${errorMessage}`
+          });
+        }
+      }
+      this.log(`Completed tool execution`, { toolCallsExecuted });
+    }
+    this.log("Max iterations reached, forcing completion", { iterations, toolCallsExecuted });
+    messages.push({
+      role: "user",
+      content: "Please provide your final analysis and commit message based on your investigation. Do not request any more tools."
+    });
+    const finalResponse = await createCompletionWithRetry(
+      messages,
+      {
+        model,
+        openaiReasoning: openaiReasoning || void 0,
+        debug,
+        storage,
+        logger: logger2
+      }
+    );
+    messages.push({
+      role: "assistant",
+      content: finalResponse
+    });
+    return {
+      finalMessage: finalResponse,
+      iterations,
+      toolCallsExecuted,
+      conversationHistory: messages,
+      toolMetrics: this.toolMetrics
+    };
+  }
+  /**
+   * Format tool result for inclusion in conversation
+   */
+  formatToolResult(result) {
+    if (typeof result.result === "string") {
+      return result.result;
+    }
+    return JSON.stringify(result.result, null, 2);
+  }
+  /**
+   * Log a message if logger is available
+   */
+  log(message, data) {
+    if (this.logger?.debug) {
+      if (data) {
+        this.logger.debug(`[AgenticExecutor] ${message}`, data);
+      } else {
+        this.logger.debug(`[AgenticExecutor] ${message}`);
+      }
+    }
+  }
+}
+async function runAgentic(config) {
+  const executor = new AgenticExecutor(config.logger);
+  return await executor.run(config);
+}
+class ToolRegistry {
+  tools = /* @__PURE__ */ new Map();
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Register a tool in the registry
+   */
+  register(tool) {
+    if (this.tools.has(tool.name)) {
+      throw new Error(`Tool with name "${tool.name}" is already registered`);
+    }
+    this.tools.set(tool.name, tool);
+  }
+  /**
+   * Register multiple tools at once
+   */
+  registerAll(tools) {
+    for (const tool of tools) {
+      this.register(tool);
+    }
+  }
+  /**
+   * Get a tool by name
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * Get all registered tools
+   */
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Check if a tool exists
+   */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * Execute a tool by name with given parameters
+   */
+  async execute(name, params) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new Error(`Tool "${name}" not found in registry`);
+    }
+    try {
+      return await tool.execute(params, this.context);
+    } catch (error) {
+      throw new Error(`Tool "${name}" execution failed: ${error.message}`);
+    }
+  }
+  /**
+   * Convert tools to OpenAI function calling format
+   */
+  toOpenAIFormat() {
+    return this.getAll().map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }
+    }));
+  }
+  /**
+   * Get tool definitions (without execute functions) for serialization
+   */
+  getDefinitions() {
+    return this.getAll().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }));
+  }
+  /**
+   * Clear all registered tools
+   */
+  clear() {
+    this.tools.clear();
+  }
+  /**
+   * Get count of registered tools
+   */
+  count() {
+    return this.tools.size;
+  }
+}
+function createToolRegistry(context) {
+  return new ToolRegistry(context);
+}
+function createCommitTools() {
+  return [
+    createGetFileHistoryTool$1(),
+    createGetFileContentTool$1(),
+    createSearchCodebaseTool$1(),
+    createGetRelatedTestsTool$1(),
+    createGetFileDependenciesTool$1(),
+    createAnalyzeDiffSectionTool$1(),
+    createGetRecentCommitsTool$1(),
+    createGroupFilesByConcernTool$1()
+  ];
+}
+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",
+    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$1() {
+  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$1() {
+  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$1() {
+  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$1() {
+  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$1() {
+  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$1() {
+  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$1() {
+  return {
+    name: "group_files_by_concern",
+    description: "Analyze changed files and suggest logical groupings that might represent separate commits",
+    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 might be better as separate commits if they represent different concerns.` : "\n\nSuggestion: All files appear to be related and should be in a single commit.";
+      return output + suggestion;
+    }
+  };
+}
+async function runAgenticCommit(config) {
+  const {
+    changedFiles,
+    diffContent,
+    userDirection,
+    logContext,
+    model = "gpt-4o",
+    maxIterations = 10,
+    debug = false,
+    debugRequestFile,
+    debugResponseFile,
+    storage,
+    logger: logger2,
+    openaiReasoning
+  } = config;
+  const toolRegistry = createToolRegistry({
+    workingDirectory: process.cwd(),
+    storage,
+    logger: logger2
+  });
+  const tools = createCommitTools();
+  toolRegistry.registerAll(tools);
+  const systemPrompt = buildSystemPrompt$1();
+  const userMessage = buildUserMessage$1(changedFiles, diffContent, userDirection, logContext);
+  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$1(result.finalMessage);
+  return {
+    commitMessage: parsed.commitMessage,
+    iterations: result.iterations,
+    toolCallsExecuted: result.toolCallsExecuted,
+    suggestedSplits: parsed.suggestedSplits,
+    conversationHistory: result.conversationHistory,
+    toolMetrics: result.toolMetrics
+  };
+}
+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:
+- get_file_history: View commit history for files
+- get_file_content: Read full file contents
+- search_codebase: Search for patterns across the codebase
+- get_related_tests: Find test files related to changes
+- get_file_dependencies: Understand file dependencies and imports
+- analyze_diff_section: Get expanded context around specific changes
+- get_recent_commits: See recent commits to the same files
+- group_files_by_concern: Suggest logical groupings of changed files
+
+Your process should be:
+1. Analyze the changed files and diff to understand the scope
+2. Use tools to investigate specific changes that need more context
+3. Identify if changes represent one cohesive commit or multiple logical commits
+4. Generate a commit message (or multiple if splits suggested) that accurately describes changes
+
+Guidelines:
+- Use tools strategically - don't call every tool on every file
+- Look at test changes to understand intent
+- Check recent history to avoid redundant messages
+- Consider suggesting split commits for unrelated changes
+- Synthesize findings into clear, informative commit messages
+- Follow conventional commit format when appropriate (feat:, fix:, refactor:, etc.)
+
+Output format:
+When you're ready to provide the final commit message, format it as:
+
+COMMIT_MESSAGE:
+[Your generated commit message here]
+
+If you recommend splitting into multiple commits, also include:
+
+SUGGESTED_SPLITS:
+Split 1:
+Files: [list of files]
+Rationale: [why these belong together]
+Message: [commit message for this split]
+
+Split 2:
+...
+
+If changes should remain as one commit, do not include SUGGESTED_SPLITS section.`;
+}
+function buildUserMessage$1(changedFiles, diffContent, userDirection, logContext) {
+  let message = `I have staged changes that need a commit message.
+
+Changed files (${changedFiles.length}):
+${changedFiles.map((f) => `  - ${f}`).join("\n")}
+
+Diff:
+${diffContent}`;
+  if (userDirection) {
+    message += `
+
+User direction: ${userDirection}`;
+  }
+  if (logContext) {
+    message += `
+
+Recent commit history for context:
+${logContext}`;
+  }
+  message += `
+
+Please investigate these changes and generate an appropriate commit message.
+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$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 = [];
+  const splitsMatch = finalMessage.match(/SUGGESTED_SPLITS:\s*\n([\s\S]*)/);
+  if (splitsMatch) {
+    const splitsText = splitsMatch[1];
+    const splitRegex = /Split \d+:\s*\nFiles: ([\s\S]*?)\nRationale: ([\s\S]*?)\nMessage: ([\s\S]*?)(?=\n\nSplit \d+:|$)/g;
+    let match;
+    while ((match = splitRegex.exec(splitsText)) !== null) {
+      const filesText = match[1].trim();
+      const files = filesText.split("\n").map((line) => line.trim().replace(/^[-*]\s*/, "")).filter((line) => line.length > 0);
+      suggestedSplits.push({
+        files,
+        rationale: match[2].trim(),
+        message: match[3].trim()
+      });
+    }
+  }
+  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,
   STANDARD_CHOICES,
   SecureTempFile,
+  ToolRegistry,
   cleanupTempFile,
   createCommitPrompt,
+  createCommitTools,
   createCompletion,
   createCompletionWithRetry,
   createNoOpLogger,
   createReleasePrompt,
+  createReleaseTools,
   createReviewPrompt,
   createSecureTempFile,
+  createToolRegistry,
   editContentInEditor,
   getLLMFeedbackInEditor,
   getLogger,
@@ -817,6 +2453,9 @@ export {
   isRateLimitError,
   isTokenLimitError,
   requireTTY,
+  runAgentic,
+  runAgenticCommit,
+  runAgenticRelease,
   setLogger,
   transcribeAudio,
   tryLoadWinston