@eldrforge/ai-service 0.1.1

package/dist/index.js

@@ -0,0 +1,816 @@
+import { OpenAI } from "openai";
+import { safeJsonParse } from "@eldrforge/git-tools";
+import fs$1 from "fs";
+import { spawnSync } from "child_process";
+import * as path from "path";
+import path__default from "path";
+import * as os from "os";
+import * as fs from "fs/promises";
+import { recipe } from "@riotprompt/riotprompt";
+import { fileURLToPath } from "url";
+let logger;
+function setLogger(customLogger) {
+  logger = customLogger;
+}
+function createNoOpLogger() {
+  return {
+    info: () => {
+    },
+    error: () => {
+    },
+    warn: () => {
+    },
+    debug: () => {
+    }
+  };
+}
+function tryLoadWinston() {
+  try {
+    const winston = require("winston");
+    if (winston && winston.createLogger) {
+      return winston.createLogger({
+        level: "info",
+        format: winston.format.simple(),
+        transports: [new winston.transports.Console()]
+      });
+    }
+  } catch {
+  }
+  return null;
+}
+function getLogger() {
+  if (logger) {
+    return logger;
+  }
+  const winstonLogger = tryLoadWinston();
+  if (winstonLogger) {
+    logger = winstonLogger;
+    return winstonLogger;
+  }
+  return createNoOpLogger();
+}
+function getModelForCommand(config, commandName) {
+  let commandModel;
+  switch (commandName) {
+    case "commit":
+    case "audio-commit":
+      commandModel = config.commands?.commit?.model;
+      break;
+    case "release":
+      commandModel = config.commands?.release?.model;
+      break;
+    case "review":
+    case "audio-review":
+      commandModel = config.commands?.review?.model;
+      break;
+  }
+  return commandModel || config.model || "gpt-4o-mini";
+}
+function getOpenAIReasoningForCommand(config, commandName) {
+  let commandReasoning;
+  switch (commandName) {
+    case "commit":
+    case "audio-commit":
+      commandReasoning = config.commands?.commit?.reasoning;
+      break;
+    case "release":
+      commandReasoning = config.commands?.release?.reasoning;
+      break;
+    case "review":
+    case "audio-review":
+      commandReasoning = config.commands?.review?.reasoning;
+      break;
+  }
+  return commandReasoning || config.reasoning || "low";
+}
+class OpenAIError extends Error {
+  constructor(message, isTokenLimitError2 = false) {
+    super(message);
+    this.isTokenLimitError = isTokenLimitError2;
+    this.name = "OpenAIError";
+  }
+}
+function isTokenLimitError(error) {
+  if (!error?.message) return false;
+  const message = error.message.toLowerCase();
+  return message.includes("maximum context length") || message.includes("context_length_exceeded") || message.includes("token limit") || message.includes("too many tokens") || message.includes("reduce the length");
+}
+function isRateLimitError(error) {
+  if (!error?.message && !error?.code && !error?.status) return false;
+  if (error.status === 429 || error.code === "rate_limit_exceeded") {
+    return true;
+  }
+  if (error.message) {
+    const message = error.message.toLowerCase();
+    return message.includes("rate limit exceeded") || message.includes("too many requests") || message.includes("quota exceeded") || message.includes("rate") && message.includes("limit");
+  }
+  return false;
+}
+async function createCompletion(messages, options = { model: "gpt-4o-mini" }) {
+  const logger2 = options.logger || getLogger();
+  let openai = null;
+  try {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new OpenAIError("OPENAI_API_KEY environment variable is not set");
+    }
+    const timeoutMs = parseInt(process.env.OPENAI_TIMEOUT_MS || "300000");
+    openai = new OpenAI({
+      apiKey,
+      timeout: timeoutMs
+    });
+    const modelToUse = options.model || "gpt-4o-mini";
+    const requestSize = JSON.stringify(messages).length;
+    const requestSizeKB = (requestSize / 1024).toFixed(2);
+    const reasoningInfo = options.openaiReasoning ? ` | Reasoning: ${options.openaiReasoning}` : "";
+    logger2.info("🤖 Making request to OpenAI");
+    logger2.info("   Model: %s%s", modelToUse, reasoningInfo);
+    logger2.info("   Request size: %s KB (%s bytes)", requestSizeKB, requestSize.toLocaleString());
+    logger2.debug("Sending prompt to OpenAI: %j", messages);
+    const maxCompletionTokens = options.openaiMaxOutputTokens ?? options.maxTokens ?? 1e4;
+    if (options.debug && (options.debugRequestFile || options.debugFile) && options.storage) {
+      const requestData = {
+        model: modelToUse,
+        messages,
+        max_completion_tokens: maxCompletionTokens,
+        response_format: options.responseFormat,
+        reasoning_effort: options.openaiReasoning
+      };
+      const debugFile = options.debugRequestFile || options.debugFile;
+      await options.storage.writeTemp(debugFile, JSON.stringify(requestData, null, 2));
+      logger2.debug("Wrote request debug file to %s", debugFile);
+    }
+    const apiOptions = {
+      model: modelToUse,
+      messages,
+      max_completion_tokens: maxCompletionTokens,
+      response_format: options.responseFormat
+    };
+    if (options.openaiReasoning && (modelToUse.includes("gpt-5") || modelToUse.includes("o3"))) {
+      apiOptions.reasoning_effort = options.openaiReasoning;
+    }
+    const startTime = Date.now();
+    const completionPromise = openai.chat.completions.create(apiOptions);
+    let timeoutId = null;
+    const timeoutPromise = new Promise((_, reject) => {
+      const timeoutMs2 = parseInt(process.env.OPENAI_TIMEOUT_MS || "300000");
+      timeoutId = setTimeout(() => reject(new OpenAIError(`OpenAI API call timed out after ${timeoutMs2 / 1e3} seconds`)), timeoutMs2);
+    });
+    let completion;
+    try {
+      completion = await Promise.race([completionPromise, timeoutPromise]);
+    } finally {
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+      }
+    }
+    const elapsedTime = Date.now() - startTime;
+    if (options.debug && (options.debugResponseFile || options.debugFile) && options.storage) {
+      const debugFile = options.debugResponseFile || options.debugFile;
+      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();
+    if (!response) {
+      throw new OpenAIError("No response received from OpenAI");
+    }
+    const responseSize = response.length;
+    const responseSizeKB = (responseSize / 1024).toFixed(2);
+    logger2.info("   Response size: %s KB (%s bytes)", responseSizeKB, responseSize.toLocaleString());
+    const elapsedTimeFormatted = elapsedTime >= 1e3 ? `${(elapsedTime / 1e3).toFixed(1)}s` : `${elapsedTime}ms`;
+    logger2.info("   Time: %s", elapsedTimeFormatted);
+    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() || "?"
+      );
+    }
+    logger2.debug("Received response from OpenAI: %s...", response.substring(0, 30));
+    if (options.responseFormat) {
+      return safeJsonParse(response, "OpenAI API response");
+    } else {
+      return response;
+    }
+  } catch (error) {
+    logger2.error("Error calling OpenAI API: %s %s", error.message, error.stack);
+    const isTokenError = isTokenLimitError(error);
+    throw new OpenAIError(`Failed to create completion: ${error.message}`, isTokenError);
+  } finally {
+  }
+}
+async function createCompletionWithRetry(messages, options = { model: "gpt-4o-mini" }, retryCallback) {
+  const logger2 = options.logger || getLogger();
+  const maxRetries = 3;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const messagesToSend = attempt === 1 ? messages : retryCallback ? await retryCallback(attempt) : messages;
+      return await createCompletion(messagesToSend, options);
+    } catch (error) {
+      if (error instanceof OpenAIError && error.isTokenLimitError && attempt < maxRetries && retryCallback) {
+        logger2.warn("Token limit exceeded on attempt %d/%d, retrying with reduced content...", attempt, maxRetries);
+        const backoffMs = Math.min(1e3 * Math.pow(2, attempt - 1), 1e4);
+        await new Promise((resolve) => setTimeout(resolve, backoffMs));
+        continue;
+      } else if (isRateLimitError(error) && attempt < maxRetries) {
+        const backoffMs = Math.min(2e3 * Math.pow(2, attempt - 1), 15e3);
+        logger2.warn(`Rate limit hit on attempt ${attempt}/${maxRetries}, waiting ${backoffMs}ms before retry...`);
+        await new Promise((resolve) => setTimeout(resolve, backoffMs));
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new OpenAIError("Max retries exceeded");
+}
+async function transcribeAudio(filePath, options = { model: "whisper-1" }) {
+  const logger2 = options.logger || getLogger();
+  let openai = null;
+  let audioStream = null;
+  let streamClosed = false;
+  const closeAudioStream = () => {
+    if (audioStream && !streamClosed) {
+      try {
+        if (typeof audioStream.destroy === "function" && !audioStream.destroyed) {
+          audioStream.destroy();
+        }
+        streamClosed = true;
+        logger2.debug("Audio stream closed successfully");
+      } catch (streamErr) {
+        logger2.debug("Failed to destroy audio read stream: %s", streamErr.message);
+        streamClosed = true;
+      }
+    }
+  };
+  try {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new OpenAIError("OPENAI_API_KEY environment variable is not set");
+    }
+    openai = new OpenAI({
+      apiKey
+    });
+    logger2.debug("Transcribing audio file: %s", filePath);
+    if (options.debug && (options.debugRequestFile || options.debugFile) && options.storage) {
+      const requestData = {
+        model: options.model || "whisper-1",
+        file: filePath,
+        // Can't serialize the stream, so just save the file path
+        response_format: "json"
+      };
+      const debugFile = options.debugRequestFile || options.debugFile;
+      await options.storage.writeTemp(debugFile, JSON.stringify(requestData, null, 2));
+      logger2.debug("Wrote request debug file to %s", debugFile);
+    }
+    audioStream = fs$1.createReadStream(filePath);
+    if (audioStream && typeof audioStream.on === "function") {
+      audioStream.on("error", (streamError) => {
+        logger2.error("Audio stream error: %s", streamError.message);
+        closeAudioStream();
+      });
+    }
+    let transcription;
+    try {
+      transcription = await openai.audio.transcriptions.create({
+        model: options.model || "whisper-1",
+        file: audioStream,
+        response_format: "json"
+      });
+      closeAudioStream();
+    } catch (apiError) {
+      closeAudioStream();
+      throw apiError;
+    }
+    if (options.debug && (options.debugResponseFile || options.debugFile) && options.storage) {
+      const debugFile = options.debugResponseFile || options.debugFile;
+      await options.storage.writeTemp(debugFile, JSON.stringify(transcription, null, 2));
+      logger2.debug("Wrote response debug file to %s", debugFile);
+    }
+    const response = transcription;
+    if (!response) {
+      throw new OpenAIError("No transcription received from OpenAI");
+    }
+    logger2.debug("Received transcription from OpenAI: %s", response);
+    if (options.onArchive) {
+      try {
+        await options.onArchive(filePath, response.text);
+      } catch (archiveError) {
+        logger2.warn("Failed to archive audio file: %s", archiveError.message);
+      }
+    }
+    return response;
+  } catch (error) {
+    logger2.error("Error transcribing audio file: %s %s", error.message, error.stack);
+    throw new OpenAIError(`Failed to transcribe audio: ${error.message}`);
+  } finally {
+    closeAudioStream();
+  }
+}
+async function getUserChoice(prompt, choices, options = {}) {
+  const logger2 = options.logger || getLogger();
+  logger2.info(prompt);
+  choices.forEach((choice) => {
+    logger2.info(`   [${choice.key}] ${choice.label}`);
+  });
+  logger2.info("");
+  if (!process.stdin.isTTY) {
+    logger2.error("⚠️  STDIN is piped but interactive mode is enabled");
+    logger2.error("   Interactive prompts cannot be used when input is piped");
+    logger2.error("   Solutions:");
+    logger2.error("   • Use terminal input instead of piping");
+    if (options.nonTtyErrorSuggestions) {
+      options.nonTtyErrorSuggestions.forEach((suggestion) => {
+        logger2.error(`   • ${suggestion}`);
+      });
+    }
+    return "s";
+  }
+  return new Promise((resolve, reject) => {
+    let isResolved = false;
+    let dataHandler = null;
+    let errorHandler = null;
+    const cleanup = () => {
+      if (dataHandler) {
+        process.stdin.removeListener("data", dataHandler);
+      }
+      if (errorHandler) {
+        process.stdin.removeListener("error", errorHandler);
+      }
+      try {
+        if (process.stdin.setRawMode) {
+          process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+        if (typeof process.stdin.unref === "function") {
+          process.stdin.unref();
+        }
+      } catch {
+      }
+    };
+    const safeResolve = (value) => {
+      if (!isResolved) {
+        isResolved = true;
+        cleanup();
+        resolve(value);
+      }
+    };
+    const safeReject = (error) => {
+      if (!isResolved) {
+        isResolved = true;
+        cleanup();
+        reject(error);
+      }
+    };
+    try {
+      if (typeof process.stdin.ref === "function") {
+        process.stdin.ref();
+      }
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      dataHandler = (key) => {
+        try {
+          const keyStr = key.toString().toLowerCase();
+          const choice = choices.find((c) => c.key === keyStr);
+          if (choice) {
+            logger2.info(`Selected: ${choice.label}
+`);
+            safeResolve(choice.key);
+          }
+        } catch (error) {
+          safeReject(error instanceof Error ? error : new Error("Unknown error processing input"));
+        }
+      };
+      errorHandler = (error) => {
+        safeReject(error);
+      };
+      process.stdin.on("data", dataHandler);
+      process.stdin.on("error", errorHandler);
+    } catch (error) {
+      safeReject(error instanceof Error ? error : new Error("Failed to setup input handlers"));
+    }
+  });
+}
+class SecureTempFile {
+  fd = null;
+  filePath;
+  isCleanedUp = false;
+  logger;
+  constructor(filePath, fd, logger2) {
+    this.filePath = filePath;
+    this.fd = fd;
+    this.logger = logger2 || getLogger();
+  }
+  /**
+   * Create a secure temporary file with proper permissions and atomic operations
+   * @param prefix Prefix for the temporary filename
+   * @param extension File extension (e.g., '.txt', '.md')
+   * @param logger Optional logger instance
+   * @returns Promise resolving to SecureTempFile instance
+   */
+  static async create(prefix = "ai-service", extension = ".txt", logger2) {
+    const tmpDir = os.tmpdir();
+    const log = logger2 || getLogger();
+    if (!process.env.VITEST) {
+      try {
+        await fs.access(tmpDir, fs.constants.W_OK);
+      } catch (error) {
+        try {
+          await fs.mkdir(tmpDir, { recursive: true, mode: 448 });
+        } catch (mkdirError) {
+          throw new Error(`Temp directory not writable: ${tmpDir} - ${error.message}. Failed to create: ${mkdirError.message}`);
+        }
+      }
+    }
+    const tmpFilePath = path.join(tmpDir, `${prefix}_${Date.now()}_${Math.random().toString(36).substring(7)}${extension}`);
+    let fd;
+    try {
+      fd = await fs.open(tmpFilePath, "wx", 384);
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        throw new Error(`Temporary file already exists: ${tmpFilePath}`);
+      }
+      throw new Error(`Failed to create temporary file: ${error.message}`);
+    }
+    return new SecureTempFile(tmpFilePath, fd, log);
+  }
+  /**
+   * Get the file path (use with caution in external commands)
+   */
+  get path() {
+    if (this.isCleanedUp) {
+      throw new Error("Temp file has been cleaned up");
+    }
+    return this.filePath;
+  }
+  /**
+   * Write content to the temporary file
+   */
+  async writeContent(content) {
+    if (!this.fd || this.isCleanedUp) {
+      throw new Error("Temp file is not available for writing");
+    }
+    await this.fd.writeFile(content, "utf8");
+  }
+  /**
+   * Read content from the temporary file
+   */
+  async readContent() {
+    if (!this.fd || this.isCleanedUp) {
+      throw new Error("Temp file is not available for reading");
+    }
+    const content = await this.fd.readFile("utf8");
+    return content;
+  }
+  /**
+   * Close the file handle
+   */
+  async close() {
+    if (this.fd && !this.isCleanedUp) {
+      await this.fd.close();
+      this.fd = null;
+    }
+  }
+  /**
+   * Securely cleanup the temporary file - prevents TOCTOU by using file descriptor
+   */
+  async cleanup() {
+    if (this.isCleanedUp) {
+      return;
+    }
+    try {
+      if (this.fd) {
+        await this.fd.close();
+        this.fd = null;
+      }
+      await fs.unlink(this.filePath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        this.logger.warn(`Failed to cleanup temp file ${this.filePath}: ${error.message}`);
+      }
+    } finally {
+      this.isCleanedUp = true;
+    }
+  }
+}
+async function createSecureTempFile(prefix = "ai-service", extension = ".txt", logger2) {
+  const secureTempFile = await SecureTempFile.create(prefix, extension, logger2);
+  await secureTempFile.close();
+  return secureTempFile.path;
+}
+async function cleanupTempFile(filePath, logger2) {
+  const log = logger2 || getLogger();
+  try {
+    await fs.unlink(filePath);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      log.warn(`Failed to cleanup temp file ${filePath}: ${error.message}`);
+    }
+  }
+}
+async function editContentInEditor(content, templateLines = [], fileExtension = ".txt", editor, logger2) {
+  const log = logger2 || getLogger();
+  const editorCmd = editor || process.env.EDITOR || process.env.VISUAL || "vi";
+  const secureTempFile = await SecureTempFile.create("ai-service_edit", fileExtension, log);
+  try {
+    const templateContent = [
+      ...templateLines,
+      ...templateLines.length > 0 ? [""] : [],
+      // Add separator if we have template lines
+      content,
+      ""
+    ].join("\n");
+    await secureTempFile.writeContent(templateContent);
+    await secureTempFile.close();
+    log.info(`📝 Opening ${editorCmd} to edit content...`);
+    const result = spawnSync(editorCmd, [secureTempFile.path], { stdio: "inherit" });
+    if (result.error) {
+      throw new Error(`Failed to launch editor '${editorCmd}': ${result.error.message}`);
+    }
+    const fileContent = (await fs.readFile(secureTempFile.path, "utf8")).split("\n").filter((line) => !line.trim().startsWith("#")).join("\n").trim();
+    if (!fileContent) {
+      throw new Error("Content is empty after editing");
+    }
+    log.info("✅ Content updated successfully");
+    return {
+      content: fileContent,
+      wasEdited: fileContent !== content.trim()
+    };
+  } finally {
+    await secureTempFile.cleanup();
+  }
+}
+const STANDARD_CHOICES = {
+  CONFIRM: { key: "c", label: "Confirm and proceed" },
+  EDIT: { key: "e", label: "Edit in editor" },
+  SKIP: { key: "s", label: "Skip and abort" },
+  IMPROVE: { key: "i", label: "Improve with LLM feedback" }
+};
+async function getUserTextInput(prompt, options = {}) {
+  const logger2 = options.logger || getLogger();
+  if (!process.stdin.isTTY) {
+    logger2.error("⚠️  STDIN is piped but interactive text input is required");
+    logger2.error("   Interactive text input cannot be used when input is piped");
+    logger2.error("   Solutions:");
+    logger2.error("   • Use terminal input instead of piping");
+    if (options.nonTtyErrorSuggestions) {
+      options.nonTtyErrorSuggestions.forEach((suggestion) => {
+        logger2.error(`   • ${suggestion}`);
+      });
+    }
+    throw new Error("Interactive text input requires a terminal");
+  }
+  logger2.info(prompt);
+  logger2.info("(Press Enter when done, or type Ctrl+C to cancel)");
+  logger2.info("");
+  return new Promise((resolve, reject) => {
+    let inputBuffer = "";
+    let isResolved = false;
+    let dataHandler = null;
+    let errorHandler = null;
+    const cleanup = () => {
+      if (dataHandler) {
+        process.stdin.removeListener("data", dataHandler);
+      }
+      if (errorHandler) {
+        process.stdin.removeListener("error", errorHandler);
+      }
+      try {
+        process.stdin.pause();
+        if (typeof process.stdin.unref === "function") {
+          process.stdin.unref();
+        }
+      } catch {
+      }
+    };
+    const safeResolve = (value) => {
+      if (!isResolved) {
+        isResolved = true;
+        cleanup();
+        resolve(value);
+      }
+    };
+    const safeReject = (error) => {
+      if (!isResolved) {
+        isResolved = true;
+        cleanup();
+        reject(error);
+      }
+    };
+    try {
+      if (typeof process.stdin.ref === "function") {
+        process.stdin.ref();
+      }
+      process.stdin.setEncoding("utf8");
+      process.stdin.resume();
+      dataHandler = (chunk) => {
+        try {
+          inputBuffer += chunk;
+          if (inputBuffer.includes("\n")) {
+            const userInput = inputBuffer.replace(/\n$/, "").trim();
+            if (userInput === "") {
+              logger2.warn("Empty input received. Please provide feedback text.");
+              safeReject(new Error("Empty input received"));
+            } else {
+              logger2.info(`✅ Received feedback: "${userInput}"
+`);
+              safeResolve(userInput);
+            }
+          }
+        } catch (error) {
+          safeReject(error instanceof Error ? error : new Error("Unknown error processing input"));
+        }
+      };
+      errorHandler = (error) => {
+        safeReject(error);
+      };
+      process.stdin.on("data", dataHandler);
+      process.stdin.on("error", errorHandler);
+    } catch (error) {
+      safeReject(error instanceof Error ? error : new Error("Failed to setup input handlers"));
+    }
+  });
+}
+async function getLLMFeedbackInEditor(contentType, currentContent, editor, logger2) {
+  const templateLines = [
+    "# Provide Your Instructions and Guidance for a Revision Here",
+    "#",
+    "# Type your guidance above this line. Be specific about what you want changed,",
+    "# added, or improved. You can also edit the original content below directly",
+    "# to provide examples or show desired changes.",
+    "#",
+    '# Lines starting with "#" will be ignored.',
+    "",
+    "### YOUR FEEDBACK AND GUIDANCE:",
+    "",
+    "# (Type your improvement instructions here)",
+    "",
+    `### ORIGINAL ${contentType.toUpperCase()}:`,
+    ""
+  ];
+  const result = await editContentInEditor(
+    currentContent,
+    templateLines,
+    ".md",
+    editor,
+    logger2
+  );
+  const lines = result.content.split("\n");
+  const originalSectionIndex = lines.findIndex(
+    (line) => line.trim().toLowerCase().startsWith("### original")
+  );
+  let feedback;
+  if (originalSectionIndex >= 0) {
+    feedback = lines.slice(0, originalSectionIndex).join("\n").trim();
+  } else {
+    feedback = result.content.trim();
+  }
+  feedback = feedback.replace(/^### YOUR FEEDBACK AND GUIDANCE:\s*/i, "").trim();
+  if (!feedback) {
+    throw new Error("No feedback provided. Please provide improvement instructions.");
+  }
+  return feedback;
+}
+function requireTTY(errorMessage = "Interactive mode requires a terminal. Use --dry-run instead.", logger2) {
+  const log = logger2 || getLogger();
+  if (!process.stdin.isTTY) {
+    log.error("❌ Interactive mode requires a terminal (TTY)");
+    log.error("   Solutions:");
+    log.error("   • Run without piping input");
+    log.error("   • Use --dry-run to see the generated content");
+    throw new Error(errorMessage);
+  }
+}
+const __filename$3 = fileURLToPath(import.meta.url);
+const __dirname$3 = path__default.dirname(__filename$3);
+const createCommitPrompt = async ({ overridePaths: _overridePaths, overrides: _overrides }, { diffContent, userDirection, isFileContent, githubIssuesContext }, { logContext, context, directories } = {}) => {
+  const basePath = __dirname$3;
+  const contentItems = [];
+  const contextItems = [];
+  if (userDirection) {
+    contentItems.push({ content: userDirection, title: "User Direction" });
+  }
+  if (diffContent) {
+    const contentTitle = isFileContent ? "Project Files" : "Diff";
+    contentItems.push({ content: diffContent, title: contentTitle });
+  }
+  if (githubIssuesContext) {
+    contentItems.push({ content: githubIssuesContext, title: "Recent GitHub Issues" });
+  }
+  if (logContext) {
+    contextItems.push({ content: logContext, title: "Log Context" });
+  }
+  if (context) {
+    contextItems.push({ content: context, title: "User Context" });
+  }
+  if (directories && directories.length > 0) {
+    contextItems.push({ directories, title: "Directories" });
+  }
+  return recipe(basePath).persona({ path: "personas/you.md" }).instructions({ path: "instructions/commit.md" }).overridePaths(_overridePaths ?? []).overrides(_overrides ?? true).content(...contentItems).context(...contextItems).cook();
+};
+const __filename$2 = fileURLToPath(import.meta.url);
+const __dirname$2 = path__default.dirname(__filename$2);
+const analyzeReleaseSize = (logContent, diffContent, milestoneIssues) => {
+  const logLines = logContent.split("\n").length;
+  const diffLines = diffContent ? diffContent.split("\n").length : 0;
+  const milestoneLines = milestoneIssues ? milestoneIssues.split("\n").length : 0;
+  const totalContentLength = logContent.length + (diffContent?.length || 0) + (milestoneIssues?.length || 0);
+  const isLarge = logLines > 60 || diffLines > 500 || milestoneLines > 50 || totalContentLength > 5e4;
+  if (isLarge) {
+    return { isLarge: true, maxTokens: 25e3 };
+  } else {
+    return { isLarge: false, maxTokens: 1e4 };
+  }
+};
+const createReleasePrompt = async ({ overrides: _overrides, overridePaths: _overridePaths }, { releaseFocus, logContent, diffContent, milestoneIssues }, { context, directories } = {}) => {
+  const basePath = __dirname$2;
+  const { isLarge: isLargeRelease, maxTokens } = analyzeReleaseSize(logContent, diffContent, milestoneIssues);
+  const contentItems = [];
+  const contextItems = [];
+  if (diffContent) {
+    contentItems.push({ content: diffContent, title: "Diff" });
+  }
+  if (logContent) {
+    contentItems.push({ content: logContent, title: "Log Context" });
+  }
+  if (milestoneIssues) {
+    contentItems.push({ content: milestoneIssues, title: "Resolved Issues from Milestone" });
+  }
+  if (releaseFocus) {
+    contentItems.push({ content: releaseFocus, title: "Release Focus" });
+  }
+  if (isLargeRelease) {
+    contextItems.push({
+      content: `This appears to be a LARGE RELEASE with significant changes. Please provide comprehensive, detailed release notes that thoroughly document all major changes, improvements, and fixes. Don't summarize - dive deep into the details.`,
+      title: "Release Size Context"
+    });
+  }
+  if (context) {
+    contextItems.push({ content: context, title: "User Context" });
+  }
+  if (directories && directories.length > 0) {
+    contextItems.push({ directories, title: "Directories" });
+  }
+  const prompt = await recipe(basePath).persona({ path: "personas/releaser.md" }).instructions({ path: "instructions/release.md" }).overridePaths(_overridePaths ?? []).overrides(_overrides ?? true).content(...contentItems).context(...contextItems).cook();
+  return {
+    prompt,
+    maxTokens,
+    isLargeRelease
+  };
+};
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path__default.dirname(__filename$1);
+const createReviewPrompt = async ({ overridePaths: _overridePaths, overrides: _overrides }, { notes }, { logContext, diffContext, releaseNotesContext, issuesContext, context, directories } = {}) => {
+  const basePath = __dirname$1;
+  const contentItems = [];
+  const contextItems = [];
+  if (notes) {
+    contentItems.push({ content: notes, title: "Review Notes" });
+  }
+  if (logContext) {
+    contextItems.push({ content: logContext, title: "Log Context" });
+  }
+  if (diffContext) {
+    contextItems.push({ content: diffContext, title: "Diff Context" });
+  }
+  if (releaseNotesContext) {
+    contextItems.push({ content: releaseNotesContext, title: "Release Notes Context" });
+  }
+  if (issuesContext) {
+    contextItems.push({ content: issuesContext, title: "Issues Context" });
+  }
+  if (context) {
+    contextItems.push({ content: context, title: "User Context" });
+  }
+  if (directories && directories.length > 0) {
+    contextItems.push({ directories, title: "Directories" });
+  }
+  return recipe(basePath).persona({ path: "personas/you.md" }).instructions({ path: "instructions/review.md" }).overridePaths(_overridePaths ?? []).overrides(_overrides ?? true).content(...contentItems).context(...contextItems).cook();
+};
+export {
+  OpenAIError,
+  STANDARD_CHOICES,
+  SecureTempFile,
+  cleanupTempFile,
+  createCommitPrompt,
+  createCompletion,
+  createCompletionWithRetry,
+  createNoOpLogger,
+  createReleasePrompt,
+  createReviewPrompt,
+  createSecureTempFile,
+  editContentInEditor,
+  getLLMFeedbackInEditor,
+  getLogger,
+  getModelForCommand,
+  getOpenAIReasoningForCommand,
+  getUserChoice,
+  getUserTextInput,
+  isRateLimitError,
+  isTokenLimitError,
+  requireTTY,
+  setLogger,
+  transcribeAudio,
+  tryLoadWinston
+};
+//# sourceMappingURL=index.js.map