@eldrforge/ai-service 0.1.8 → 0.1.10

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,790 @@ 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(),
+    createGetFileContentTool(),
+    createSearchCodebaseTool(),
+    createGetRelatedTestsTool(),
+    createGetFileDependenciesTool(),
+    createAnalyzeDiffSectionTool(),
+    createGetRecentCommitsTool(),
+    createGroupFilesByConcernTool()
+  ];
+}
+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 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();
+  const userMessage = buildUserMessage(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(result.finalMessage);
+  return {
+    commitMessage: parsed.commitMessage,
+    iterations: result.iterations,
+    toolCallsExecuted: result.toolCallsExecuted,
+    suggestedSplits: parsed.suggestedSplits,
+    conversationHistory: result.conversationHistory,
+    toolMetrics: result.toolMetrics
+  };
+}
+function buildSystemPrompt() {
+  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(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(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 };
+}
 export {
+  AgenticExecutor,
   OpenAIError,
   STANDARD_CHOICES,
   SecureTempFile,
+  ToolRegistry,
   cleanupTempFile,
   createCommitPrompt,
+  createCommitTools,
   createCompletion,
   createCompletionWithRetry,
   createNoOpLogger,
   createReleasePrompt,
   createReviewPrompt,
   createSecureTempFile,
+  createToolRegistry,
   editContentInEditor,
   getLLMFeedbackInEditor,
   getLogger,
@@ -817,6 +1610,8 @@ export {
   isRateLimitError,
   isTokenLimitError,
   requireTTY,
+  runAgentic,
+  runAgenticCommit,
   setLogger,
   transcribeAudio,
   tryLoadWinston